Valen's Memory Safety: A New Kind of Borrow Checking

Valen's Memory Safety: A New Kind of Borrow Checking(verdagon.dev)

36 points by verdagon 2 hours ago | 19 comments

peesem 48 minutes ago |

nit: you need a better way of laying out asides/footnotes. when they get bunched up like at the start of this article you start having to scroll full screens back and forth. at least make the numbers on the asides link back to their position in the main text

verdagon 45 minutes ago | |

Yes, absolutely, lol. This article is really pushing my notes system past its limits. And it loops between six note colors, which normally isn't a problem, but is here. During the holidays, I want to see if I can implement Tufte notes like in https://edwardtufte.github.io/tufte-css/

giovannibonetti 1 hour ago |

I wonder if nowadays we should be focusing less on scalar data structures and more on languages that facilitate vectorized/SIMD instructions. Languages like Vx lang, Mojo, and Futhark that work both in the CPU or the GPU, although each one works in a different level of abstraction and control.

verdagon 56 minutes ago | |

GPU compilation is definitely something I intend Valen to support. I wrote about it back in 2022, [0] and I learned a lot of lessons on how to do it (and how not to do it!) from working on the Mojo compiler.

The biggest decision for Valen is what to lower to:

* Rust MIR, since rustc has CUDA now, [1] (perhaps other cards soon?)

* SPIR-V, like Zig does for its GPU compilation [2]

* MLIR

Rust MIR is looking pretty nice. Valen already has Rust interop by doing some rustc sorcery, [3] and it would be somewhat straightforward to switch from emitting LLVM to emitting Rust MIR. I just need to figure out if Rust MIR can support the optimizations I have planned for Valen.

In a perfect world, Rust would be able to lower its MIR to MLIR, since MLIR has so many backends. I recall there were some efforts to do that, unsure where that ended up.

[0] https://verdagon.dev/blog/next-gen-languages-gpu

[1] https://developer.nvidia.com/blog/introducing-cuda-rust-two-...

[2] https://ziglang.org/devlog/2026/#2026-06-26

[3] https://verdagon.dev/blog/golden-spike-reviving-vale-valen

392 1 hour ago | |

You are in good company.

https://venge.net/graydon/talks/VectorizedInterpretersTalk-2...

cmontella 54 minutes ago | | |

I don’t want to hijack Evan’s post by posting a link, but if you’re interested I’ve implemented many of the ideas in that presentation in the language I’m working on. You can check out the latest link in my post history for a rundown of how it works and a demo.

verdagon 2 hours ago |

Also, as I was writing this, a couple things occurred to me:

* We _could_ use the function parameter syntax `entities: &world.entities[]` instead of `entities in world.entities[]`.

* "Groups" aren't really central to understanding the idea, so Path Borrowing might be a better name than Group Borrowing.

Opinions welcome =)

munchler 1 hour ago | |

FWIW `foo in bar` implies iteration to me, not a path. In the .NET world, for example, `bar` would be a collection that we’re iterating through, assigning each element to `foo` in turn.

maufl 1 hour ago |

How likely is it that such a borrow checker could be "backported" to Rust? Maybe in a new edition?

verdagon 47 minutes ago | |

You know, it's not crazy. Niko wrote about lifetimes based on places back in 2024, [0] though it was in the context of shared-xor-mutable, which is consistent with Rust's spirit.

And Rust already supports forms of mutable aliasing already, such as with Cell, and GhostCell which is halfway towards Valen's approach. I would love to see someone augment GhostCell to have the sort of "invalidation" logic that group borrowing does. In fact, Plecra is working on something like that with their (WIP) "Exclusion Typing". [1]

On top of that, Polonius already thinks in terms of "paths", just like Valen does. So it's not so much a question of compiler design, but of language design, and how Rust would expose it to the user.

[0] https://smallcultfollowing.com/babysteps/blog/2024/06/02/the...

[1] https://dilated.me/blog/posts/introduction-to-exclusion-typi...

user142 50 minutes ago |

I noticed that there is no control flow in the examples.

verdagon 41 minutes ago | |

Next article =) How the borrow checker handles ifs and loops is a pretty fun topic. If-statements work like you'd expect (invalidations from both branches are merged). Loops is where it gets weird: we have to scout all the invalidations that happen inside the loop and then "replay" them _before_ the body of the loop. I can explain it more if you'd like.

user142 26 minutes ago | | |

I was wondering about the case where a reference points to a different path depending on control flow. I guess you can just design your language to make this impossible but this is still possible to do with pointers in C/C++.

sebastianmestre 2 hours ago |

IIRC this Verdagon guy had a language called Vale... is Valen a rename or a new project?

Edit: tfa makes it clear it's a separate project

verdagon 2 hours ago | |

Hi! Kind of both. Even though Valen reuses 90% of the Vale compiler, its approach (Rust interop, borrow checking with mutable aliasing, etc.) is so different that it really needed a new name.

Also, I really like where Vale ended up, Vale's generational references + region borrowing was a truly weird and unusual memory safety blend. I didn't want that combination to be lost to time, so I wanted "Vale" to keep referring to that.

fithisux 46 minutes ago |

Is it possible to retrofit it to Freepascal, D, Freebasic or even Java?

verdagon 27 minutes ago | |

Maybe! I think about D a lot when designing Valen, since they attempted to blend borrowing with garbage collection. Swift is facing some of the same challenges, and I expect Java could soon too now that Valhalla has landed.

If Valen solves those challenges as well as I think it can, it could be a good direction for them to explore.