News for hackers. Stuff that matters.

Gesee

Re:Nimony: A New Compiler for Nim on Wednesday November 18, 2026 @07:52AM (#50545719)
GC is optional in the sense "don't use `ref` types and there will be no GC" Value types (`object`) use mutable value semantics and scope based destructors, so there are safe without GC
Re:Nimony: A New Compiler for Nim on Wednesday November 18, 2026 @06:32AM (#50545012)
No need for that, I checked it, it's a good little language but not near Rust or Nim The way you designed bound checking, parameter inferences is more a source of bugs than anything I didn't see support for advanced closures and how it's integrated with the borrow checker (since you claim not having lifetimes, there are tons of unanswered questions in your thing)

Your desing of generic instantiation is just a compile time pit. You don't constraint type so you need to check the body of every instance

You have NLL yeah, but not partial borrows nor the capacity for a proc to return one of it's parameters (the famous example

```rs

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { if x.len() > y.len() { x } else { y } }

```

since you don't have lifetimes, either you refuse this case or it's a bug if you do a copy then your language asks it's user to use value semantics

But if your language mostly push users to value semantics (a.k.a copying tons of things) then why all the borrow stuff ? If there is no lifetime how is one suposed to store references ? why is there a ref, ref_mut type ?

Those are overly convoluted choices for a value based language So it's a bit of an incoherence

Next there is the way you handle indexing your spec state that undecided index access generate stricta_bounds_fail, but this function just output an error and exit the process, it doesn't insert a runtime check

So undecided index access act as nuke in the codebase, the users is not even aware that one of it's access is undecided, and when he expect it the less he just get the process stopped, no exceptions, just a crash

Then you don't even correctly handle cyclic data type structure, you defined in the codebase an arbitrary depth of 16 instead of checking type cycle (and what you stated in your spec just worked auto referencing types like type A with a field of type A again

Re:Nimony: A New Compiler for Nim on Wednesday November 18, 2026 @04:58AM (#50544235)
I don't think we can call that transpilation as it's not a 1:1 conversion But yeah, the native backend and LLVM backend definitively close the "transpilation" door
Re:Nimony: A New Compiler for Nim on Wednesday November 18, 2026 @04:56AM (#50544214)
Refcounting only cause problem when using `ref` counted type, which is also discouraged most of the time when not necessary.