Rue: Higher level than Rust, lower level than Go

Memory safety & management

• Homepage promise “memory safe; no GC; no manual management” prompts many questions.
• Current state: no heap allocation at all; safety is trivial for now.
• Planned approach: linear types (must-use) plus mutable value semantics, with no references/lifetimes and likely no ARC.
• This is contrasted with Rust’s affine types and borrow checker; Rue explicitly aims to avoid lifetimes and the lowest‑level performance niche.
• Liveness/long‑running memory and concurrency semantics are acknowledged as open problems; async story is “totally unsure.”
• Some commenters are skeptical, pointing to V’s “autofree + partial GC” as a cautionary tale and noting that “memory safe without GC” is quite hard.

Positioning between Rust and Go

• The “higher than Rust, lower than Go” slogan is debated; people disagree on what “high‑” vs “low‑level” even means (machine closeness, type‑system complexity, abstraction level, etc.).
• Rue’s author clarifies: not trying to compete with C/C++/Rust on raw speed, won’t add a GC, likely will require a runtime, and might not even have unsafe.
• Not aimed at kernels/embedded; closer in spirit to OCaml/Swift/Hylo than to D, but with more imperative/FP than OOP.
• Targeted niche is ergonomics and compile times rather than extreme performance.

Language design & features

• Syntax currently very close to Rust, with @ intrinsics inspired by Zig; Rust syntax is reused to avoid bikeshedding while semantics and compiler internals are explored.
• Algebraic data types (enums) have just been added; generics and broader abstraction strategy are still in flux.
• No plans for classical OOP inheritance or subtyping; traits/sum types are preferred, which disappoints some C++‑style OOP users.
• Interest in Swift/Hylo-style mutable value semantics, Vale’s research, and linear types/regions is explicitly acknowledged.

TCO, examples, and ergonomics

• Naive recursive Fibonacci as a demo example upsets some, who see it as a sign the language might lack tail call optimization.
• TCO is discussed as a semantic feature (enabling recursion-as-loops) rather than just an optimization; author is considering an explicit annotation to preserve useful backtraces.
• There’s a side debate over punctuation-heavy syntax (semicolons, :, ->), with some finding it noisy and others defending it for readability.

Project maturity & reception

• Rue is described as a personal, exploratory project; future production use is uncertain.
• Concurrency model, FFI story, and metaprogramming (macros vs codegen) are explicitly undecided.
• The thread’s attention is attributed mainly to interest in new languages and the author’s track record, with some noting that the current state is “just promises and a factorial demo.”