--- title: How the Rust Standard Library Verification Contest... description: The Rust Foundation and AWS's crowdsourced verification contest for the Rust standard library has moved past manual proof engineering, which plateaued after... canonical: https://daily.dev/posts/how-the-rust-standard-library-verification-contest-scaled-past-manual-proof-engineering-bpgvgi9fw twitter:card: summary_large_image twitter:site: @dailydotdev og:type: website og:site_name: daily.dev og:title: How the Rust Standard Library Verification Contest Scaled Past Manual Proof Engineering | daily.dev og:description: The Rust Foundation and AWS's crowdsourced verification contest for the Rust standard library has moved past manual proof engineering, which plateaued after... og:url: https://daily.dev/posts/how-the-rust-standard-library-verification-contest-scaled-past-manual-proof-engineering-bpgvgi9fw og:image: https://api.daily.dev/og/posts/BPGVGI9FW.png og:image:alt: How the Rust Standard Library Verification Contest Scaled Past Manual Proof Engineering og:image:width: 1200 og:image:height: 630 og:locale: en --- > ## Documentation Index > Fetch the complete documentation index at: https://daily.dev/llms.txt > Use this file to discover all available pages before exploring further. # How the Rust Standard Library Verification Contest Scaled Past Manual Proof Engineering **[Rust Foundation](https://daily.dev/sources/rustfoundation)** · 6 min read · 6 upvotes · 0 comments ## Summary The Rust Foundation and AWS's crowdsourced verification contest for the Rust standard library has moved past manual proof engineering, which plateaued after 725 hand-written Kani harnesses and 50+ VeriFast proofs. A new AWS-built tool, Autoharness, automatically generates proof harnesses at the MIR level, producing 16,748 harnesses and successfully verifying 11,970 functions against undefined behavior classes like out-of-bounds access and null pointer dereferences. A separate VeriFast proof of LinkedList using separation logic verified 19 functions with pointer-heavy heap manipulation. No new memory-safety vulnerabilities were found, but several documentation and specification issues were fixed. Remaining challenges include 9,600 generic functions that Autoharness must skip due to monomorphization, and concurrency primitives like atomics and Arc that remain unsolved. ## Full article daily.dev links to this article rather than hosting it. Read it at the original source: ## Questions this post answers ### What is Autoharness and how does it improve Rust standard library verification? Autoharness is a tool built by the AWS Kani team that automatically generates proof harnesses at the MIR level without requiring source changes, enumerating every eligible function in a crate and calling it with fully symbolic inputs. It produced 16,748 proof harnesses, with 11,970 successfully verified against undefined behavior classes, an order of magnitude beyond fifteen months of manual harness writing. _Developers tracking formal verification progress in Rust follow tooling breakthroughs like this on daily.dev._ ### What kinds of undefined behavior can Kani's Autoharness detect in Rust code? Kani's Autoharness checks for out-of-bounds access, null and dangling pointer dereferences, use of uninitialized memory, and arithmetic overflow in unsafe contexts. Of 16,748 generated harnesses, including 4,645 for unsafe functions, 11,970 were successfully verified against these classes, though not all carry equally strong guarantees since some lack explicit preconditions. _Engineers weighing verification tools for unsafe Rust code can follow these findings on daily.dev._ ### Why can't Autoharness verify generic functions or concurrent data structures in the Rust standard library? Autoharness currently skips over 9,600 generic functions because Rust monomorphizes generics at compile time, making automatic instantiation-based checking scale poorly. Concurrency remains another open gap, since challenges targeting atomic types and Arc are unsolved, and reasoning soundly about lock-free data structures under a relaxed memory model is still genuinely hard. _Teams evaluating the limits of automated verification tooling can track this progress on daily.dev._ ## Similar posts on daily.dev - [Rust-proof your code with our new Testing Handbook chapter](https://daily.dev/posts/rust-proof-your-code-with-our-new-testing-handbook-chapter-syjpwdje5) · Trail of Bits Blog · 1 upvotes · 0 comments --- Tags: [#rust](https://daily.dev/tags/rust) [View this post on daily.dev](https://daily.dev/posts/how-the-rust-standard-library-verification-contest-scaled-past-manual-proof-engineering-bpgvgi9fw) ```json {"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://daily.dev/#organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180},"sameAs":["https://twitter.com/dailydotdev","https://github.com/dailydotdev","https://www.linkedin.com/company/daily-dev-ltd"]},{"@type":"WebSite","@id":"https://daily.dev/#website","url":"https://daily.dev","name":"daily.dev","publisher":{"@id":"https://daily.dev/#organization"},"potentialAction":{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https://daily.dev/search?q={search_term_string}"},"query-input":"required name=search_term_string"}}]} {"@context":"https://schema.org","@type":"TechArticle","headline":"How the Rust Standard Library Verification Contest Scaled Past Manual Proof Engineering","url":"https://daily.dev/posts/how-the-rust-standard-library-verification-contest-scaled-past-manual-proof-engineering-bpgvgi9fw","mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/posts/how-the-rust-standard-library-verification-contest-scaled-past-manual-proof-engineering-bpgvgi9fw"},"datePublished":"2026-09-01T17:31:27.827Z","dateModified":"2026-09-01T17:50:49.670Z","description":"The Rust Foundation and AWS's crowdsourced verification contest for the Rust standard library has moved past manual proof engineering, which plateaued after...","image":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/f66440441b635c3ee239cd3473d09d65?_a=AQAEuop","thumbnailUrl":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/f66440441b635c3ee239cd3473d09d65?_a=AQAEuop","isAccessibleForFree":true,"articleSection":"Rust Foundation","inLanguage":"en","publisher":{"@type":"Organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180}},"author":{"@type":"Organization","name":"Rust Foundation","logo":"https://media.daily.dev/image/upload/t_logo,f_auto/v1/logos/7400c35e24054a098fc3b268f9b6a616","url":"https://daily.dev/sources/rustfoundation"},"commentCount":0,"discussionUrl":"https://daily.dev/posts/how-the-rust-standard-library-verification-contest-scaled-past-manual-proof-engineering-bpgvgi9fw","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":6},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":0}],"keywords":"rust","timeRequired":"PT6M"} {"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev"},{"@type":"ListItem","position":2,"name":"Rust Foundation","item":"https://daily.dev/sources/rustfoundation"},{"@type":"ListItem","position":3,"name":"How the Rust Standard Library Verification Contest Scaled Past Manual Proof Engineering"}]} {"@context":"https://schema.org","@type":"FAQPage","@id":"https://daily.dev/posts/how-the-rust-standard-library-verification-contest-scaled-past-manual-proof-engineering-bpgvgi9fw#faq","mainEntity":[{"@type":"Question","name":"What is Autoharness and how does it improve Rust standard library verification?","acceptedAnswer":{"@type":"Answer","text":"Autoharness is a tool built by the AWS Kani team that automatically generates proof harnesses at the MIR level without requiring source changes, enumerating every eligible function in a crate and calling it with fully symbolic inputs. It produced 16,748 proof harnesses, with 11,970 successfully verified against undefined behavior classes, an order of magnitude beyond fifteen months of manual harness writing. Developers tracking formal verification progress in Rust follow tooling breakthroughs like this on daily.dev."}},{"@type":"Question","name":"What kinds of undefined behavior can Kani's Autoharness detect in Rust code?","acceptedAnswer":{"@type":"Answer","text":"Kani's Autoharness checks for out-of-bounds access, null and dangling pointer dereferences, use of uninitialized memory, and arithmetic overflow in unsafe contexts. Of 16,748 generated harnesses, including 4,645 for unsafe functions, 11,970 were successfully verified against these classes, though not all carry equally strong guarantees since some lack explicit preconditions. Engineers weighing verification tools for unsafe Rust code can follow these findings on daily.dev."}},{"@type":"Question","name":"Why can't Autoharness verify generic functions or concurrent data structures in the Rust standard library?","acceptedAnswer":{"@type":"Answer","text":"Autoharness currently skips over 9,600 generic functions because Rust monomorphizes generics at compile time, making automatic instantiation-based checking scale poorly. Concurrency remains another open gap, since challenges targeting atomic types and Arc are unsolved, and reasoning soundly about lock-free data structures under a relaxed memory model is still genuinely hard. Teams evaluating the limits of automated verification tooling can track this progress on daily.dev."}}]} ```