{"slug": "verus", "name": "Verus", "category": "other", "category_name": "Other software", "description": "A tool for formally verifying the correctness of Rust code using SMT-backed proofs.", "recommenders": 6, "commenters": 7, "warners": 0, "score": 5.899, "rising": 0.69, "first": "2026-04-22", "latest": "2026-10-23", "why": "Liked for integrating proofs directly into Rust code in a programmer-friendly way that coding agents handle well.", "why_is_quote": false, "has_verdict": true, "sentiment": {"recommend": 6, "neutral": 1, "compare": 0, "warn": 0}, "spark": [0, 0, 0, 0, 0, 2, 0, 0, 2, 0, 1, 1], "listed": true, "loved": ["Rust integration", "Works with LLMs"], "caveat": "Custom syntax", "short_quote": "it's genuinely amazing. I have been using it on my own Rust codebases for a while", "icon": true, "domain": null, "github_repo": "github.com/verus-lang/verus", "official_url": "https://github.com/verus-lang/verus", "pricing": "open source", "aliases": ["Verus"], "verdict": [{"text": "Liked for integrating proofs directly into Rust code", "cites": [{"id": 803264416, "item_id": 50204026, "url": "https://news.ycombinator.com/item?id=50204026", "by": "gregwebs", "date": "2026-10-23", "stance": "recommend", "quote": "I think they found a nice way to integrate proofs with the language.", "excerpt": "I have a skill for using Verus with Rust [1]. I think they found a nice way to integrate proofs with the language. The verify skill I use lists proofs as a possible technique [2] and the project instructions have instructions on using it, but only a very small fraction of the code base I am using this on has proofs. Anyone can now have an LLM write proofs but its still difficult to know when they are more productive ", "context": "", "use_case": "Rust formal verification", "switched_from": "", "story": "LLMs are making formal software verification feasible at a much larger scale"}, {"id": 780440992, "item_id": 48777562, "url": "https://news.ycombinator.com/item?id=48777562", "by": "twoWhlsGud", "date": "2026-07-03", "stance": "recommend", "quote": "extensions like Verus, I think, are trying to enable exactly what the author is discussing. Perhaps worth a look", "excerpt": "Interesting. In the Rust world extensions like Verus, I think, are trying to enable exactly what the author is discussing. Perhaps worth a look: https://github.com/verus-lang/verus", "context": "", "use_case": "Rust verification", "switched_from": "", "story": "Local Reasoning for Global Properties"}, {"id": 796009584, "item_id": 49750599, "url": "https://news.ycombinator.com/item?id=49750599", "by": "txhwind", "date": "2026-09-18", "stance": "neutral", "quote": "integrates proof with macro in Rust", "excerpt": "I'm interested in how to integrate formal verification with existing software libraries. For example, https://github.com/verus-lang/verus integrates proof with macro in Rust. What's the plan for Bend?", "context": "", "use_case": "formal verification for Rust", "switched_from": "", "story": "Bend \u2013 a language that blocks AI mistakes via proof and runs on GPUs"}, {"id": 785034400, "item_id": 49064650, "url": "https://news.ycombinator.com/item?id=49064650", "by": "gz09", "date": "2026-07-26", "stance": "recommend", "quote": "Verus (https://github.com/verus-lang/verus) is a good start for the rust ecosystem", "excerpt": "Strongly agree with the author here. The future will belong to programming languages that natively embed theorem proofers into their type systems so LLMs can forego a lot of testing by just validating the implementations they write against the specs with formal proofs. Writing formal specs is probably the main skill a programmer in the future will need to get work done. Verus (https://github.com/verus-lang/verus) is ", "context": "", "use_case": "formal verification for Rust", "switched_from": "", "story": "We have proof automation now"}]}, {"text": " in a programmer-friendly way that coding agents handle well.", "cites": [{"id": 765974112, "item_id": 47873382, "url": "https://news.ycombinator.com/item?id=47873382", "by": "Animats", "date": "2026-04-23", "stance": "recommend", "quote": "It's much more programmer-friendly than some other approaches.", "excerpt": "Oh, that takes me back to 1982.[1] This is very similar to what we did back then. The syntactical approach is almost identical. It's much more programmer-friendly than some other approaches. One of the problems with proof of correctness is that the people doing it tend to fall in love with the formalism, and it all becomes too abstract and hard. This project didn't do that. It's not clear what they do when they need ", "context": "worked on proof-of-correctness systems in 1982", "use_case": "verifying Rust code", "switched_from": "", "story": "Verus is a tool for verifying the correctness of code written in Rust"}, {"id": 801378384, "item_id": 50086149, "url": "https://news.ycombinator.com/item?id=50086149", "by": "gregwebs", "date": "2026-10-14", "stance": "recommend", "quote": "I have found that agents are good at writing Verus proofs in a Rust code base, and that these proofs have only a minimal negative effect on the normal compilation path.", "excerpt": "Rust does have one glaring weakness: compile times. I suspect in the LLM era we will see the rise of a language or perhaps some sort of Rust redesign that achieves what Rust has with great performance and great type safety but also has better support for fast compilation. I have found that agents are good at writing Verus proofs in a Rust code base, and that these proofs have only a minimal negative effect on the nor", "context": "", "use_case": "proofs in Rust codebases", "switched_from": "", "story": "What agents mean for Rust (and vice versa)"}]}, {"text": " The most cited caveat is that it is still essentially a standalone language with its own syntax,", "cites": [{"id": 785034400, "item_id": 49064650, "url": "https://news.ycombinator.com/item?id=49064650", "by": "gz09", "date": "2026-07-26", "stance": "recommend", "quote": "Verus (https://github.com/verus-lang/verus) is a good start for the rust ecosystem", "excerpt": "Strongly agree with the author here. The future will belong to programming languages that natively embed theorem proofers into their type systems so LLMs can forego a lot of testing by just validating the implementations they write against the specs with formal proofs. Writing formal specs is probably the main skill a programmer in the future will need to get work done. Verus (https://github.com/verus-lang/verus) is ", "context": "", "use_case": "formal verification for Rust", "switched_from": "", "story": "We have proof automation now"}]}, {"text": " and it is unclear how it handles proofs beyond what an SMT solver can do.", "cites": [{"id": 765974112, "item_id": 47873382, "url": "https://news.ycombinator.com/item?id=47873382", "by": "Animats", "date": "2026-04-23", "stance": "recommend", "quote": "It's much more programmer-friendly than some other approaches.", "excerpt": "Oh, that takes me back to 1982.[1] This is very similar to what we did back then. The syntactical approach is almost identical. It's much more programmer-friendly than some other approaches. One of the problems with proof of correctness is that the people doing it tend to fall in love with the formalism, and it all becomes too abstract and hard. This project didn't do that. It's not clear what they do when they need ", "context": "worked on proof-of-correctness systems in 1982", "use_case": "verifying Rust code", "switched_from": "", "story": "Verus is a tool for verifying the correctness of code written in Rust"}]}], "praise": [{"label": "Rust integration", "summary": "Commenters like how it embeds proofs into Rust code.", "quotes": [{"id": 803264416, "item_id": 50204026, "url": "https://news.ycombinator.com/item?id=50204026", "by": "gregwebs", "date": "2026-10-23", "stance": "recommend", "quote": "I think they found a nice way to integrate proofs with the language.", "excerpt": "I have a skill for using Verus with Rust [1]. I think they found a nice way to integrate proofs with the language. The verify skill I use lists proofs as a possible technique [2] and the project instructions have instructions on using it, but only a very small fraction of the code base I am using this on has proofs. Anyone can now have an LLM write proofs but its still difficult to know when they are more productive ", "context": "", "use_case": "Rust formal verification", "switched_from": "", "story": "LLMs are making formal software verification feasible at a much larger scale"}, {"id": 796009584, "item_id": 49750599, "url": "https://news.ycombinator.com/item?id=49750599", "by": "txhwind", "date": "2026-09-18", "stance": "neutral", "quote": "integrates proof with macro in Rust", "excerpt": "I'm interested in how to integrate formal verification with existing software libraries. For example, https://github.com/verus-lang/verus integrates proof with macro in Rust. What's the plan for Bend?", "context": "", "use_case": "formal verification for Rust", "switched_from": "", "story": "Bend \u2013 a language that blocks AI mistakes via proof and runs on GPUs"}, {"id": 780440992, "item_id": 48777562, "url": "https://news.ycombinator.com/item?id=48777562", "by": "twoWhlsGud", "date": "2026-07-03", "stance": "recommend", "quote": "extensions like Verus, I think, are trying to enable exactly what the author is discussing. Perhaps worth a look", "excerpt": "Interesting. In the Rust world extensions like Verus, I think, are trying to enable exactly what the author is discussing. Perhaps worth a look: https://github.com/verus-lang/verus", "context": "", "use_case": "Rust verification", "switched_from": "", "story": "Local Reasoning for Global Properties"}]}, {"label": "Works with LLMs", "summary": "Coding agents are reported to write Verus proofs well in Rust codebases.", "quotes": [{"id": 801378384, "item_id": 50086149, "url": "https://news.ycombinator.com/item?id=50086149", "by": "gregwebs", "date": "2026-10-14", "stance": "recommend", "quote": "I have found that agents are good at writing Verus proofs in a Rust code base, and that these proofs have only a minimal negative effect on the normal compilation path.", "excerpt": "Rust does have one glaring weakness: compile times. I suspect in the LLM era we will see the rise of a language or perhaps some sort of Rust redesign that achieves what Rust has with great performance and great type safety but also has better support for fast compilation. I have found that agents are good at writing Verus proofs in a Rust code base, and that these proofs have only a minimal negative effect on the nor", "context": "", "use_case": "proofs in Rust codebases", "switched_from": "", "story": "What agents mean for Rust (and vice versa)"}, {"id": 803264416, "item_id": 50204026, "url": "https://news.ycombinator.com/item?id=50204026", "by": "gregwebs", "date": "2026-10-23", "stance": "recommend", "quote": "I think they found a nice way to integrate proofs with the language.", "excerpt": "I have a skill for using Verus with Rust [1]. I think they found a nice way to integrate proofs with the language. The verify skill I use lists proofs as a possible technique [2] and the project instructions have instructions on using it, but only a very small fraction of the code base I am using this on has proofs. Anyone can now have an LLM write proofs but its still difficult to know when they are more productive ", "context": "", "use_case": "Rust formal verification", "switched_from": "", "story": "LLMs are making formal software verification feasible at a much larger scale"}]}, {"label": "Programmer-friendly", "summary": "Seen as more approachable than other proof-of-correctness approaches.", "quotes": [{"id": 765974112, "item_id": 47873382, "url": "https://news.ycombinator.com/item?id=47873382", "by": "Animats", "date": "2026-04-23", "stance": "recommend", "quote": "It's much more programmer-friendly than some other approaches.", "excerpt": "Oh, that takes me back to 1982.[1] This is very similar to what we did back then. The syntactical approach is almost identical. It's much more programmer-friendly than some other approaches. One of the problems with proof of correctness is that the people doing it tend to fall in love with the formalism, and it all becomes too abstract and hard. This project didn't do that. It's not clear what they do when they need ", "context": "worked on proof-of-correctness systems in 1982", "use_case": "verifying Rust code", "switched_from": "", "story": "Verus is a tool for verifying the correctness of code written in Rust"}, {"id": 765949376, "item_id": 47871836, "url": "https://news.ycombinator.com/item?id=47871836", "by": "suobset", "date": "2026-04-22", "stance": "recommend", "quote": "it's genuinely amazing. I have been using it on my own Rust codebases for a while", "excerpt": "I just attended a talk at Northeastern (Boston) on Verus, it's genuinely amazing. I have been using it on my own Rust codebases for a while, and it has made me think deeper about the structure and semantics of Rust code.", "context": "", "use_case": "verifying Rust code", "switched_from": "", "story": "Verus is a tool for verifying the correctness of code written in Rust"}]}, {"label": "Low build impact", "summary": "Proofs add little cost to normal compilation and can run as a separate step.", "quotes": [{"id": 801378384, "item_id": 50086149, "url": "https://news.ycombinator.com/item?id=50086149", "by": "gregwebs", "date": "2026-10-14", "stance": "recommend", "quote": "I have found that agents are good at writing Verus proofs in a Rust code base, and that these proofs have only a minimal negative effect on the normal compilation path.", "excerpt": "Rust does have one glaring weakness: compile times. I suspect in the LLM era we will see the rise of a language or perhaps some sort of Rust redesign that achieves what Rust has with great performance and great type safety but also has better support for fast compilation. I have found that agents are good at writing Verus proofs in a Rust code base, and that these proofs have only a minimal negative effect on the nor", "context": "", "use_case": "proofs in Rust codebases", "switched_from": "", "story": "What agents mean for Rust (and vice versa)"}, {"id": 795943056, "item_id": 49746441, "url": "https://news.ycombinator.com/item?id=49746441", "by": "Jtsummers", "date": "2026-09-17", "stance": "recommend", "quote": "Their tutorial seems ok", "excerpt": "Proof happens before compilation, and doesn't require compilation. You can follow the Verus tutorials for the specifics, but you can use it as a standalone verifier or as a compilation \"stage\" where it'll run its verification and then conditionally continue on to compilation. Their tutorial seems ok: https://verus-lang.github.io/verus/guide/overview.html But if you want a more complete tutorial on this concept using ", "context": "", "use_case": "Rust formal verification", "switched_from": "", "story": "Developing provably correct Rust code with Verus"}]}], "caveats": [{"label": "Custom syntax", "summary": "Described as essentially a standalone language with its own syntax and type system.", "quotes": [{"id": 785034400, "item_id": 49064650, "url": "https://news.ycombinator.com/item?id=49064650", "by": "gz09", "date": "2026-07-26", "stance": "recommend", "quote": "Verus (https://github.com/verus-lang/verus) is a good start for the rust ecosystem", "excerpt": "Strongly agree with the author here. The future will belong to programming languages that natively embed theorem proofers into their type systems so LLMs can forego a lot of testing by just validating the implementations they write against the specs with formal proofs. Writing formal specs is probably the main skill a programmer in the future will need to get work done. Verus (https://github.com/verus-lang/verus) is ", "context": "", "use_case": "formal verification for Rust", "switched_from": "", "story": "We have proof automation now"}]}, {"label": "SMT limits", "summary": "It is unclear how it handles proofs beyond what an SMT solver can do.", "quotes": [{"id": 765974112, "item_id": 47873382, "url": "https://news.ycombinator.com/item?id=47873382", "by": "Animats", "date": "2026-04-23", "stance": "recommend", "quote": "It's much more programmer-friendly than some other approaches.", "excerpt": "Oh, that takes me back to 1982.[1] This is very similar to what we did back then. The syntactical approach is almost identical. It's much more programmer-friendly than some other approaches. One of the problems with proof of correctness is that the people doing it tend to fall in love with the formalism, and it all becomes too abstract and hard. This project didn't do that. It's not clear what they do when they need ", "context": "worked on proof-of-correctness systems in 1982", "use_case": "verifying Rust code", "switched_from": "", "story": "Verus is a tool for verifying the correctness of code written in Rust"}]}, {"label": "Unclear payoff", "summary": "It is hard to know when proofs are more productive than other techniques.", "quotes": [{"id": 803264416, "item_id": 50204026, "url": "https://news.ycombinator.com/item?id=50204026", "by": "gregwebs", "date": "2026-10-23", "stance": "recommend", "quote": "I think they found a nice way to integrate proofs with the language.", "excerpt": "I have a skill for using Verus with Rust [1]. I think they found a nice way to integrate proofs with the language. The verify skill I use lists proofs as a possible technique [2] and the project instructions have instructions on using it, but only a very small fraction of the code base I am using this on has proofs. Anyone can now have an LLM write proofs but its still difficult to know when they are more productive ", "context": "", "use_case": "Rust formal verification", "switched_from": "", "story": "LLMs are making formal software verification feasible at a much larger scale"}]}, {"label": "Learning resources", "summary": "The tutorial is called only okay, and Dafny or SPARK/Ada are suggested for fuller tutorials.", "quotes": [{"id": 795943056, "item_id": 49746441, "url": "https://news.ycombinator.com/item?id=49746441", "by": "Jtsummers", "date": "2026-09-17", "stance": "recommend", "quote": "Their tutorial seems ok", "excerpt": "Proof happens before compilation, and doesn't require compilation. You can follow the Verus tutorials for the specifics, but you can use it as a standalone verifier or as a compilation \"stage\" where it'll run its verification and then conditionally continue on to compilation. Their tutorial seems ok: https://verus-lang.github.io/verus/guide/overview.html But if you want a more complete tutorial on this concept using ", "context": "", "use_case": "Rust formal verification", "switched_from": "", "story": "Developing provably correct Rust code with Verus"}]}], "who": [{"by": "Animats", "context": "worked on proof-of-correctness systems in 1982", "url": "https://news.ycombinator.com/item?id=47873382", "date": "2026-04-23"}], "tags": ["for Rust developers", "for LLM agent workflows", "formal verification"], "use_cases": ["rust formal verification", "formal verification for rust", "verifying rust code", "proofs in rust codebases", "rust verification"], "compared": [], "makers": [], "threads": [{"url": "https://news.ycombinator.com/item?id=47840252", "title": "Verus is a tool for verifying the correctness of code written in Rust", "mentions": 2}, {"url": "https://news.ycombinator.com/item?id=50202217", "title": "LLMs are making formal software verification feasible at a much larger scale", "mentions": 1}, {"url": "https://news.ycombinator.com/item?id=50084416", "title": "What agents mean for Rust (and vice versa)", "mentions": 1}, {"url": "https://news.ycombinator.com/item?id=49746163", "title": "Bend \u2013 a language that blocks AI mistakes via proof and runs on GPUs", "mentions": 1}, {"url": "https://news.ycombinator.com/item?id=49700153", "title": "Developing provably correct Rust code with Verus", "mentions": 1}, {"url": "https://news.ycombinator.com/item?id=49062291", "title": "We have proof automation now", "mentions": 1}], "sentiment_by_month": {"2025-11": {}, "2025-12": {}, "2026-01": {}, "2026-02": {}, "2026-03": {}, "2026-04": {"recommend": 2}, "2026-05": {}, "2026-06": {}, "2026-07": {"recommend": 2}, "2026-08": {}, "2026-09": {"recommend": 1, "neutral": 1}, "2026-10": {"recommend": 1}}, "quotes": [{"id": 803264416, "item_id": 50204026, "url": "https://news.ycombinator.com/item?id=50204026", "by": "gregwebs", "date": "2026-10-23", "stance": "recommend", "quote": "I think they found a nice way to integrate proofs with the language.", "excerpt": "I have a skill for using Verus with Rust [1]. I think they found a nice way to integrate proofs with the language. The verify skill I use lists proofs as a possible technique [2] and the project instructions have instructions on using it, but only a very small fraction of the code base I am using this on has proofs. Anyone can now have an LLM write proofs but its still difficult to know when they are more productive ", "context": "", "use_case": "Rust formal verification", "switched_from": "", "story": "LLMs are making formal software verification feasible at a much larger scale"}, {"id": 801378384, "item_id": 50086149, "url": "https://news.ycombinator.com/item?id=50086149", "by": "gregwebs", "date": "2026-10-14", "stance": "recommend", "quote": "I have found that agents are good at writing Verus proofs in a Rust code base, and that these proofs have only a minimal negative effect on the normal compilation path.", "excerpt": "Rust does have one glaring weakness: compile times. I suspect in the LLM era we will see the rise of a language or perhaps some sort of Rust redesign that achieves what Rust has with great performance and great type safety but also has better support for fast compilation. I have found that agents are good at writing Verus proofs in a Rust code base, and that these proofs have only a minimal negative effect on the nor", "context": "", "use_case": "proofs in Rust codebases", "switched_from": "", "story": "What agents mean for Rust (and vice versa)"}, {"id": 796009584, "item_id": 49750599, "url": "https://news.ycombinator.com/item?id=49750599", "by": "txhwind", "date": "2026-09-18", "stance": "neutral", "quote": "integrates proof with macro in Rust", "excerpt": "I'm interested in how to integrate formal verification with existing software libraries. For example, https://github.com/verus-lang/verus integrates proof with macro in Rust. What's the plan for Bend?", "context": "", "use_case": "formal verification for Rust", "switched_from": "", "story": "Bend \u2013 a language that blocks AI mistakes via proof and runs on GPUs"}, {"id": 795943056, "item_id": 49746441, "url": "https://news.ycombinator.com/item?id=49746441", "by": "Jtsummers", "date": "2026-09-17", "stance": "recommend", "quote": "Their tutorial seems ok", "excerpt": "Proof happens before compilation, and doesn't require compilation. You can follow the Verus tutorials for the specifics, but you can use it as a standalone verifier or as a compilation \"stage\" where it'll run its verification and then conditionally continue on to compilation. Their tutorial seems ok: https://verus-lang.github.io/verus/guide/overview.html But if you want a more complete tutorial on this concept using ", "context": "", "use_case": "Rust formal verification", "switched_from": "", "story": "Developing provably correct Rust code with Verus"}, {"id": 785034400, "item_id": 49064650, "url": "https://news.ycombinator.com/item?id=49064650", "by": "gz09", "date": "2026-07-26", "stance": "recommend", "quote": "Verus (https://github.com/verus-lang/verus) is a good start for the rust ecosystem", "excerpt": "Strongly agree with the author here. The future will belong to programming languages that natively embed theorem proofers into their type systems so LLMs can forego a lot of testing by just validating the implementations they write against the specs with formal proofs. Writing formal specs is probably the main skill a programmer in the future will need to get work done. Verus (https://github.com/verus-lang/verus) is ", "context": "", "use_case": "formal verification for Rust", "switched_from": "", "story": "We have proof automation now"}, {"id": 780440992, "item_id": 48777562, "url": "https://news.ycombinator.com/item?id=48777562", "by": "twoWhlsGud", "date": "2026-07-03", "stance": "recommend", "quote": "extensions like Verus, I think, are trying to enable exactly what the author is discussing. Perhaps worth a look", "excerpt": "Interesting. In the Rust world extensions like Verus, I think, are trying to enable exactly what the author is discussing. Perhaps worth a look: https://github.com/verus-lang/verus", "context": "", "use_case": "Rust verification", "switched_from": "", "story": "Local Reasoning for Global Properties"}, {"id": 765974112, "item_id": 47873382, "url": "https://news.ycombinator.com/item?id=47873382", "by": "Animats", "date": "2026-04-23", "stance": "recommend", "quote": "It's much more programmer-friendly than some other approaches.", "excerpt": "Oh, that takes me back to 1982.[1] This is very similar to what we did back then. The syntactical approach is almost identical. It's much more programmer-friendly than some other approaches. One of the problems with proof of correctness is that the people doing it tend to fall in love with the formalism, and it all becomes too abstract and hard. This project didn't do that. It's not clear what they do when they need ", "context": "worked on proof-of-correctness systems in 1982", "use_case": "verifying Rust code", "switched_from": "", "story": "Verus is a tool for verifying the correctness of code written in Rust"}, {"id": 765949376, "item_id": 47871836, "url": "https://news.ycombinator.com/item?id=47871836", "by": "suobset", "date": "2026-04-22", "stance": "recommend", "quote": "it's genuinely amazing. I have been using it on my own Rust codebases for a while", "excerpt": "I just attended a talk at Northeastern (Boston) on Verus, it's genuinely amazing. I have been using it on my own Rust codebases for a while, and it has made me think deeper about the structure and semantics of Rust code.", "context": "", "use_case": "verifying Rust code", "switched_from": "", "story": "Verus is a tool for verifying the correctness of code written in Rust"}]}