News for hackers. Stuff that matters.
Re:Nimony: A New Compiler for Nim by lcnmrn on Tuesday November 17, 2026 @09:32AM (#50531903)
This feels archaic to me after seeing what is possible with Stricta. You get full Python syntax as low level as possible, safe, strict, no ARC/GC, memory access. https://github.com/lucianmarin/stricta
Re:Nimony: A New Compiler for Nim by mirrir on Tuesday November 17, 2026 @09:36AM (#50531954)
yes but that's your own project. its odd to not disclose that while calling other's work archaic.
Re:Nimony: A New Compiler for Nim by platinumrad on Tuesday November 17, 2026 @09:39AM (#50532000)
> Rust-Style Memory Safety (No GC / No ARC): Compile-time ownership and borrow checking with inferred BORROW / MUT_BORROW / MOVE parameter modes, non-lexical lifetimes (NLL), monomorphized deterministic @_drop_T / @_clone_T generation, compiler-lowered { i1, T } exception propagation, and runtime bounds traps—with zero garbage collection or reference counting overhead.

There is either a catch here or you(r LLM) has solved multiple open research problems.

Re:Nimony: A New Compiler for Nim by lcnmrn on Tuesday November 17, 2026 @10:07AM (#50532397)
Get the code and ask your LLM if it did, otherwise provide an edge case to be fixed.
Re:Nimony: A New Compiler for Nim by Gesee 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 by fishgoesblub on Tuesday November 17, 2026 @10:43AM (#50532931)
> All Rights Reserved

No thanks.

Re:Nimony: A New Compiler for Nim by ternaryoperator on Wednesday November 18, 2026 @01:26AM (#50542558)
[delayed]
Re:Nimony: A New Compiler for Nim by user8765439 on Tuesday November 17, 2026 @04:25PM (#50538406)
wow a 16k line single c file, revolutionary slop