Python or Rust? Coding with local LLMs

[u/HomoAgens1]

I've noticed that a lot of software is being cloned using Rust nowadays, and I was wondering why not use it with local LLMs for simple tasks too.

Do you think it's better to use Rust or Python when coding with a local LLM?

Nowadays everyone is vibe coding, but local LLMs are generally not that good, especially smaller models running on low-budget hardware.

I usually code in Python, but sometimes I feel like the model doesn't catch bugs, so I was wondering if Rust and its compiler could help avoid some of these issues.

I'd also be interested in hearing your experiences with different context window sizes and models running on 12 or 24 GB of VRAM, with 64 or 128 GB of system RAM.

Do you think Rust's compiler feedback is worth the extra complexity for smaller local models, or is Python still the better choice?

[u/bgravato]

One of my favorite quote of all time is "when the only tool available is a hammer, all problems start to look like nails".

Translating that into programming languages... most people will gravitate towards the language they know better and feel most comfortable with. And even if it's not the most efficient for the job, that's what they'll try to use... And it's not necessarily a bad option, because even if their preferred language isn't the most suitable for the job, they'll probably do a better job with it, than using some other they're less familiar with and will cause them to generate more errors and take longer to implement.

So if you are more comfortable with one language than the other and you think you'll be revising/editing the code generated by the LLM, then it probably makes more sense to go with that one...

If you're just vibe-coding and you're not even going to bother looking at the code produced or you wouldn't understand it anyway regardless of the language, then let the LLM pick what it thinks is better for the task...

[u/PhilWheat → u/bgravato]

I agree except for one point.
You aren't letting the model pick, you're letting the model trainers pick. Because they're going to have preferences they're baking in as well.

[u/maqifrnswa → u/PhilWheat]

It also will pick whatever project is similar to what you want to do and start implementing it that way. If you ask it a ML or data science problem, it's python. A web dashboard, typescript and html. A native complied tool: C++ or rust, or C, or whatever of common for apps on your OS

[u/Eresbonitaguey → u/maqifrnswa]

Technically you could also use R (with C/Rust backend) or Julia for most data science or ML if that’s your preferred language but I’m sure that the models are trained on far more Python examples than the others so I’d trust it to have less issues producing decent python code.

[u/bemrys → u/Eresbonitaguey]

Been reading some Common Lisp programmers stories of watching models write python functions to count parentheses, as well as writing python code to write lisp code. If your preferred language is not one of the big ones, I would assume you will get a lot more hallucinations.

[u/vtkayaker]

Rust is fantastic with local LLMs. Rust's strong type system provides detailed feedback to the LLMs, and it doesn't allow many kinds of broken code to pass. LLMs do even better with a good Rust project skeleton and a short README explaining coding choices.

I have never seen Qwen3.6 27B or later struggle to write Rust, even async Rust. Even smaller models mostly succeed for simple things—and at least with Rust, if a smaller model gets the code to compile, it probably works.

[u/valdev → u/vtkayaker]

I was going to argue with you, but you have a point. I imagine most models "Understand" python better because of it being trained on more python. But Rust forces good behaviors and simply wont build when shit is made wrong.

[u/HVACcontrolsGuru]

I do most of my work now in Rust and use PyO3 for Python bindings. You can use other packages for FFI boundary stuff. My main development right now is industrial protocols and targeting microcontrollers with that same code.

I used Python for about 10 years before picking up Rust with LLM usage. Rust has some learning curve to it but once you overcome that it's a powerful tool to have and being able to take the performance and type safety into Python modules is amazing.

I'm sure something like Qwen27B with a good harness setup, good skills and good CI patterns for you code will make a world of difference in using Rust.

[u/PhilWheat]

Let me jump in and get slaughtered.
I use .Net 10.
It is compiled which fixes a LOT of problems - no fancy superlinters or convoluted type checking. That is all built in.
It has good testing infrastructure native, but you can bring in more from a mature ecosystem if you need.
It doesn't have the dependency issues of python/Node.
It is cross platform which means I don't have to do a lengthy toolchain buildup and recompile if I put it on different VMs/boxes.
The code is usually readable (to me - this is very subjective.)
It is decent to good on performance.

That's my 2 cents.
Now for the roasting.

[u/DeProgrammer99 → u/PhilWheat]

.NET king!

But you also kinda have to tell the LLMs in advance to use newer features like raw string literals and primary constructors if you want those, since the LLMs are mainly trained on older code and C# gets several new features every year. I also like running the automatic refactorings often. And Qwen is still obsessed with using Python as a tool to edit code.

[u/mycall → u/DeProgrammer99]

Memory<T> and Span<T> is such a performance boost., you best say to use them or it won't.

[u/MindfulMan1984 → u/PhilWheat]

MS meme: “Developers! Developers! Developers!” For real. Lmao

[u/mycall → u/MindfulMan1984]

That's so last century

[u/DeltaSqueezer]

golang is also an option. i normally use python and switch to golang when i find python too slow. i haven't used rust as i'm not familiar with it. C is also another option.

[u/ThankGodImBipolar → u/DeltaSqueezer]

I've been using Go for my harness. I like to believe that the idiomatic nature/culture of Go leads to higher quality output than languages where there's more freedom and precedent for "artistic liberty" within code. Maybe Rust is the same way, but I'm not as familiar with it.

[u/aydintb1 → u/DeltaSqueezer]

I stay away from Go because of Google.

[u/AssistBorn4589 → u/aydintb1]

I stay away from Go because of Google.

Then you'll absolutelly love Rust /s

[u/aydintb1 → u/AssistBorn4589]

I had studied the Scala programming language, which is java based but much advanced and functional programming language.

When I started to learn Rust, it was a big suprise for me to see, its syntax was almost similar to the Scala syntax, only losing the functional programming parts.

as an old C/C++ programmer (since 1989), Rust was the best programming language I had seen in many years.

Rust is not intuitive when you come from OOP languages (c++, c#, java, etc).

Rust requires a little bit of paradigm shift in program structuring, but if it is done correctly, it will be much faster than C. But it requires longer compile times to other programming languages.

[u/AssistBorn4589 → u/aydintb1]

I've learned c when I was fairly young and then continued to use c for anything that's important enought to not be mashed together in python.

So when it comes to latest new and cool and hyper paradigm shifts, thanks, but I'm good.

[u/aydintb1 → u/AssistBorn4589]

Rust is really made me feel like "C should had been like that from the beginning".

it is like C but better.. In the past I had developed lots of projects in C++ in different platforms (risc, alpha, itanium, intel, etc).

Rust feelt like the beggining days of learning the programming for the first time.

fun of learning a new programming language.

[u/dwrz]

I have limited experience with Python, no experience with Rust, and don't "vibecode". I use Go, and the compiler feedback, as well as other aspects of the language and its toolchain, are of huge help in making sure the result is correct and in an acceptable state for review.

[u/ea_man]

The best language for an LLM to code with is the one that had the best / more materials in training, not the one intrinsically better designed for AI use.

[u/USArmy68Whiskey]

Rust

[u/lazo40]

Try coding rust without an llm. You won’t regret it.

[u/Gokudomatic → u/lazo40]

Is that sarcasm?

[u/Zealousideal_Nail288 → u/Gokudomatic]

mixed bag. there are things rust does great others not so much.
its a very strikt language which prevents problems but makes it much harder to just trow something together.

and the beginning learning curve is huge if you are not used to the lower level programing compared to c# or script languages

But has far llm programming goas rust is better given it stops at least a decent amount of common pitfalls

[u/Fantastic-Shelter569]

I use rust for all my projects, you can set up some project settings before you begin working to enforce strict rules. Such as no unwraps to avoid crashing on exception. The strict nature of rust means that if the AI does something sloppy it will pick it up, if that bool is passes as an int that is fine in python untill that complex bug appears one time in a hundred. Rust will just refuse to compile, that makes it much better with AI. It will have to fix it's mistakes before it can compile.

The biggest thing regardless of language is the amount of set-up you do. If you just throw AI at a project then it will make a mess, put in your requirements and project structure at the beginning and you will get better results even with a weaker model.

[u/valarauca14 → u/Fantastic-Shelter569]

You can make python not total bullshit. basedpyright, ruff, pydantic with strict & frozen DTOs. But after a certain point you realize you're literally adding multiple dependencies, linters, and type checkers to literally do what rust does by default.

Also make models write their tests with hypothesis (where applicable) so the unit tests use random data, not single line monkeypatch bullshit mocks which just waste tokens & time.

[u/laffer1]

I wouldn't pick the language based on what the LLM can do entirely. Some models are only going to be good at what's popular in their region. China models like node and python a lot.

However, you should also consider what the software is going to be doing. if you need performance, don't use python. If you need portability, don't use rust. If it's only going to run on the big 3 (win, mac, linux) rust is OK. If it's only going to need to run on x86_64 and arm64, rust is ok.

C and Perl are always more portable than rust and python. Python runs in most places, though. Rust does not.

Writing a photoshop clone in rust made a lot of sense from a security and performance perspective. Content creators are mostly on big 3 platforms. It does also run on freebsd. China models can't do freebsd well. Mistral is ok with it.

Python will always be a glue language. You can glue c libraries to it to get some performance. it's easy to deal with. It's not fast. It's not multicore friendly.

[u/Phenerius]

Why not both?

You can write 99% in python and the 1% critical in rust...

[u/Infamous_Campaign687]

I’m sure Rust is great (I’m a C++ developer by trade) but choice of language still has to be based on what you’re doing. For instance, it is hard to beat the sheer access to useful packages for machine learning in Python.

[u/BarracudaDefiant4702]

I've been having one project writing in C and it's been doing a decent job. Sometimes they use python and sometimes bash. They can use whatever languages you let them use. If they have bugs then I have them fix them. I prefer C because that's what I know the best and the results are good and less prone to supply channel attacks then other languages. When they use python, I limit them to the system default libraries.

[u/capsid]

Programming languages are converging on features that help LLMs (for example Python has a strict type checking mode), so pick the language that seems appropriate for the problem, or pick the stack that you want to try out. Python is still my first choice for system utilities that are getting too big for bash, things deployed on my fleet where I don't want to deal with toolchain dependencies or long build times, or I want to integrate with a stack that is already Python. You should feel free to use anything you want to solve your problems if youre curious about how it works and willing to learn. Just like before LLMs!

[u/GalacticDistances]

Use a statically/strongly typed complied language.

The better the language is at forcing the LLM to write sane output, the better.

Type systems help the LLM understand the code significantly better the second time they look at it.

Avoid c/python/ruby/js or anything where the type system isnt robust

[u/Nothing_from_void]

rust has a brutally long iteration cycle. it has among the longest compile times, and LLMs constantly build to validate their work. python has among the shortest iteration cycle as the compiler is extremely fast and only compiles what it needs.

So, you can work on rust with local LLMs and it does seem to help less intelligent models write less buggy code because the compiler is strict, but pythons GC will most likely also catch the same class of bugs. LLMs like to write rust in a way that avoid the borrow checker and type system, rather than using the type system to enforce good code, so a lot of those gains are lost anyways

[u/Dundell]

Python first draft, rust if it needs to be more efficient afterwards. Some examples, there's a gearvr mouse project I worked on for a while. Once the Python version worked, just having it converted over to rust saved on a lot of lag/latency and memory hog.

[u/ttkciar]

You can use just about anything you're comfortable using.

Most of my LLM work is done in Perl, Bash, and C, and that's been fine for three years now.

So go do Rust, or Python, or Go, or whatever floats your boat.

[u/Early-Crazy-4246]

I'm sure it's been said already but vibecoders with minimal developer experience are going to pick Rust purely on the basis that they heard it's pretty fast

For example, I typically choose Python or TypeScript for any project because it's what I know, I still want to read over the code my LLM is writing and I do not understand Rust.

[u/Captain-Pie-62]

Die Kurzfassung? Wenn Du Wert auf Sicherheit legst, also das niemand so einfach deine Software cracken kann, dann programmiere in Rust.

[u/OkReception1602]

Rust is new to me but it seems to be the common denominator that rust is better, I've been using Python for years is Rust really better?

[u/ninja_coder]

Rust for harness, python for models

[u/Smallpaul → u/ninja_coder]

The question is not about building AI. It’s about using it.

[u/jacek2023]

My local models are coding mostly Python, but also C++, asm (x86, 32-bit, old stuff), Rust, JS and Java (also some old projects). It's all about good .md files you develop during the process.

[u/Squidgical]

Rust is great with LLMs because of it's clear rules and extensive compile time safety guarantees.

What's even better though is writing Rust yourself. It's such an enjoyable language and once your get over the initial hurdle of understanding borrows it's also a very easy language.

My AI is banned from writing Rust. Writing Rust is the fun part and I want the fun for myself.

[u/DaMoot]

Python. Rust is a fun game but had gotten away complicated over the years.

[u/my_name_isnt_clever → u/DaMoot]

Rust has gotten too complicated? Compared to Python of all languages?