Doo: a Simple, Fast Programming Language Built on Rust and Llvm
Key topics
https://github.com/nynrathod/doolang
I'm Nayan, and I'm stoked to share Doo, my project turned side hustle for a lang that's dead simple to write but punches like Rust. Think clean syntax (inspired by Rust but less boilerplate), auto memory mgmt via ref counting (no GC pauses), rich types, and it spits out standalone native bins via LLVM/clang.
Why Doo? Coding should feel fun, not fighty. No more wrestling with lifetimes or macros just to get a "hello world" but still safe and speedy.
Quick tour (hello.doo):
fn main() { let msg = "Hey HN!"; print(msg); }
Static Type System: Compile-time type checking with type inference Automatic Memory Management: Reference counting for data types Rich Data Types: Integers, strings, booleans, arrays, maps, and tuples Module System: Organize code with a hierarchical import system Control Flow: Conditional statements, for loops, and range iteration Function System: First-class functions with parameter and return type annotations Native Compilation: Compiles to standalone executables using clang/lld
Repo: https://github.com/nynrathod/doolang (stars/pulls welcome!)
What do you think? Too Rust-y? Missing a killer feature?
The author introduces Doo, a new programming language that aims to combine simplicity with performance, and the community discusses its features and potential.
Snapshot generated from the HN discussion
Discussion Activity
Active discussionFirst comment
18m
Peak period
12
Day 1
Avg / period
4.5
Based on 27 loaded comments
Key moments
- 01Story posted
Nov 3, 2025 at 3:37 AM EST
2 months ago
Step 01 - 02First comment
Nov 3, 2025 at 3:55 AM EST
18m after posting
Step 02 - 03Peak activity
12 comments in Day 1
Hottest window of the conversation
Step 03 - 04Latest activity
Nov 12, 2025 at 12:52 AM EST
about 2 months ago
Step 04
Generating AI Summary...
Analyzing up to 500 comments to identify key contributors and discussion patterns
Want the full context?
Jump to the original sources
Read the primary article or dive into the live Hacker News thread when you're ready.
So main goal of this language is to have simplicity while writing code. Rust is great will dominate, but as dev who want speed and security but with high level syntax, doolang is best for them. Right now im working on std library and inbuilt function, and moving forward I will integrate doolang with my own note taking app uoozer note https://play.google.com/store/apps/details?id=com.uoozer.not... , 550+ test cases covered by doolang already with valgrind memroy test too.
so for roadmap, after inbuilt functions and standard library deployment will build http router and will test real world scenario for api dev. IF all well then will integrate with uoozer note.
Did you write it or generate? If the later, then it's could be even more impressive in some way.
Yeah make sense, but I don't have any buzzing goal right now, doolang is not any dsl, just to ensure high level syntax for developer writing backend servers apis. And not started as learning project. Will move forward as per feedback of community and requirement but not such specific target im aiming. so again simple concept is keep it simple to write with speed and security
Does it require using traits everywhere, like Rust does?
Does it have proper references (C++ style)?
Doolang not uses any traits like rust. Rust is great language, but its expose everything in syntax that is also great but as developer who want security+speed with fast development may found issue writing rust, that is main goal of doolang simlicity. I'm still figuring out further design principle of syntax to have less exposing syntax.
Doolang have auto memory management with reference counting. Just simple mut keyword introduced for mutating variable let mut data = "data"; no other syntax expose all handling automatic with rc and auto type define if not defined explicitly
About references: am I correct, that any value is reference-counted and one can pass it to a function and mutate it (the original, not a copy).
For complex types (strings, arrays, maps), values are reference-counted and passed by reference. If you pass such a value to a function, you're sharing the same object—mutations affect the original. For primitives (Int, Bool), it's pass-by-value (copy).
Only support this as of now
fn Foo(x: Int) { x = 123; // Only modifies Foo's local copy print("inside Foo", x); // Print 123 } fn main() { let x: Int = 0; Foo(x); // x is still 0 here after Foo returns print("out x", x); // Print 0 }
More recently I wrote another one DHAT https://accu.org/journals/overload/33/185/floyd/
The videos on YouTube are mostly crap. Here are a couple of good ones https://www.youtube.com/watch?v=-VDiEe9hxC4&lc=UgwLVU1SO1BUz... https://www.youtube.com/watch?v=y6AN0ks2q0A&lc=UgwQSQzkCtMRO...
Struct enums are base of any type safe language will surely add in upcoming releases.
Have you given any thought to supporting Wasm Components as a build target?
Just want to say, you did all the right things: Simple instructions, to the point and, and I can't stress this enough - examples. Like 9/10 when someone shares their language, they have little to no examples and it's the first thing people ask for.
I do think you could probably have a few more examples that are like the calculator and less of what's basically a one liner.
On the language: I like what's there so far. It's clean minimalist, and familiar.
The problem is that there's not really a USP that I can see. I get the rust but with reference counting, but I don't think that's even close to enough. There has to be a really really good reason for people to try and use a new programming language. And I don't really see the overall vision beyond a small hobby project (which is fine if that's what you were aiming for)
> Missing a killer feature?
Yes, very much so.
And really make sense your point to have usp or any unique or good feature doolang should have. As this is just starting point of doolang, and honestly i never started this as hobby project I want this to be mature over years not to replace any languge but to have simplicity for writing servers and apis. after few months I will definitely integrate this with my own production note taking app once i improve this language.
Reference counting i Introduce for auto memroy mgmt only, as rust ownership and borrow method will be extreme complex to implement as solo dev i feel.
But now im clear now language should have any special feature or target which is lacking, idk what to find for this, but it will be valuable if you can suggest, im also thinking to have new post to ask feedback from community what they want in such language. Any suggestion?