Hello Rust Community,

I wanted to share a project I've been working on that might be of interest to systems programmers and language enthusiasts: the G Language.

G is a minimalist, memory-safe interpreter designed for systems scripting, with a complete footprint of about 2.4MB. The entire toolchain is written in D (which shares Rust's focus on systems programming and zero-cost abstractions).

While built with D, G's design philosophy shares several Rust-like principles:

• Memory safety through design (not borrow checking, but through interpreter guarantees)
• Minimal runtime with no GC overhead
• Fearless systems scripting for tasks where bash is too limited but Rust might be overkill

Recently, G was accepted into the awesome-d list. I also wrote about the experience of building it and getting feedback from Walter Bright (creator of D): When Walter Bright Told Me to Write About My 2.4MB Language.

I'm sharing this here because:

1. As a case study in language implementation that might interest those building similar tools in Rust
2. For comparative discussion - how memory safety is approached differently in interpreter vs compiled contexts
3. For feedback from a community that deeply understands systems programming tradeoffs

I would be particularly interested in:

• Thoughts on the memory safety approach in an interpreter context
• Feedback on the minimalist design from Rust's "zero-cost abstraction" perspective
• Any insights on making such tools more robust or efficient

The project is GNUv3 licensed and available here: github.com/pouyathe/glang

Best regards,
Pouya Mohammadi

1 post - 1 participant

Read full topic