project-everest/vale

This system is a formal verification toolchain for the Vale programming language, designed to verify and execute code against hardware architectures. It provides a build system and infrastructure for integrating with F\* and Dafny, enabling the specification and verification of x64, ARM, and PowerPC architectures. The system supports direct execution of verified code, manages dependencies like Z3 and KreMLin, and includes comprehensive test suites to ensure correctness across different platforms.

8 changes.

This period focused on establishing the project's infrastructure, introducing a new SCons-based build system and initializing the repository structure. Significant work was also done on the Vale tooling, including refactoring the AST and typechecker, adding x86 machine model support, and creating comprehensive test suites for the Vale/F\* integration.

8 changes.

This period focused on establishing formal verification support for x86-64, PowerPC, and ARM architectures by introducing new F\* and Dafny specification files and test cases. The work included building the necessary infrastructure, such as the ImportFStarTypes tool and Docker build scripts, to enable the import and use of types from external languages and automate the CI process.

4 changes.

This period focused on expanding the formal verification capabilities of the Vale language by adding architecture-specific definitions for x64 and PowerPC64LE in F\*. Additionally, the project improved developer workflows through an interactive verification script and migrated its documentation to Read the Docs.

Introduces the foundational architecture definitions and verification interfaces for ARM and x64 processors within the Dafny/Vale project. This includes new specification files (e.g., \specs/arch/arm/def.dfy\, \specs/arch/x64/def.dfy\) defining CPU state, registers, and instruction semantics. Corresponding implementation files (\code/arch/arm/decls.vad\, \code/arch/x64/decls.vad\) provide the concrete Dafny code for these architectures, including memory access patterns and register states. The change also adds a \code/test/memcpy.vad\ test case for x64 memory copy operations, utility modules for bit operations and sequence handling, and Git attributes for the new files.

dafny · high confidence

Introduces a new tool, ImportFStarTypes, which parses F\* module output (via --dump\module) and generates .types.vaf files for Vale. This enables Vale to import and use types defined in F\ code, supporting features like preconditions, postconditions, and dependent types.

tools/ImportFStarTypes · high confidence

Introduces the foundational components for the PowerPC 64-bit little-endian (PPC64LE) architecture, including type declarations, state management, and instruction definitions. This includes the \PPC64LE.Vale.Decls\ module which defines register and vector types as integer refinement types, and the \PPC64LE.Vale.State\ module for managing CPU state. The change also adds \PPC64LE.Vale.InsBasic\ and \PPC64LE.Vale.InsMem\ to define basic and memory access instructions, \PPC64LE.Vale.InsVector\ for vector operations, and \PPC64LE.Vale.Lemmas\ for formal verification of the architecture's semantics.

fstar/code/arch/ppc64le · high confidence

A new Python script (interact.py) is introduced to facilitate interactive verification of F\* and Vale code. The script supports running F\* in IDE mode, optionally executing Vale commands before verification, and offers an auto-discovery mode to locate command files. It also provides a readline interface for improved command history and user-friendly interaction during the verification process.

python · high confidence

Introduces a new x86 machine model and a Vale interface that enables direct execution of Dafny programs in the testDirect mode. The change adds demo.vad and demoX86.vad, which define x86 instructions (Mov, Add), registers, memory, and state transitions. It also provides a Vale interface (va\\ functions) to interact with the x86 state, allowing Dafny code to be executed directly against this model.

tools/Vale/testDirect · high confidence

The tools/Kremlin directory now includes the Kremlin C library implementation (kremlib.c, kremlib.h) and F\# bindings (C.fst), along with a gcc\compat.h header that defines \\_cdecl and other calling conventions for GCC. This provides the necessary C headers and stubs to support the Kremlin tool's operation across different platforms.

tools/Kremlin · high confidence

Added new F\* specification files defining the machine state, instruction semantics, and assembly code generation for the PowerPC 64-bit Little-Endian (PPC64LE) and x86-64 architectures. These files introduce the core data structures for registers, memory, and execution state, along with the evaluation logic for instructions and control flow, enabling formal verification of hardware behaviors for these platforms.

fstar/specs/hardware · high confidence

Introduces a new \x64simple\ directory containing simplified F\* definitions for the x64 architecture. This includes state management (\X64s.Vale.State\), register and XMM register abstractions (\X64s.Vale.Regs\, \X64s.Vale.Xmms\), and a suite of lemmas (\X64s.Vale.Lemmas\) to support formal verification of x64 instructions, such as basic arithmetic, memory operations, and vector instructions.

fstar/code/arch/x64simple · high confidence

Added new F\* modules and interface files to support the QuickCode framework for the x64 architecture. This includes \Arch.Types\ and \Arch.TypesNative\ for arithmetic and bit manipulation lemmas, \X64.Vale.Decls\ for state and operand definitions, and \X64.Vale.QuickCode\ and \X64.Vale.QuickCodes\ for weakest precondition generation and state modification tracking. Additionally, \X64.Vale.InsBasic\, \X64.Vale.InsMem\, and \X64.Vale.InsVector\ define the basic, memory, and vector instruction implementations using the new QuickCode system, while \X64.Vale.Lemmas\ provides the necessary proof obligations for control flow and state transitions.

fstar/code/arch/x64 · high confidence

Added new build infrastructure for the Vale project, including build.sh and build\helper.sh scripts that automate the CI and nightly build processes, and a config.json file that defines build targets (vale-ci, vale-nightly), container settings, and versioning for F\ and Vale.

.docker/build · high confidence

The Vale documentation has been rewritten and migrated to the Read the Docs (RTD) format using Sphinx. This includes a new \conf.py\ configuration file, a custom Pygments lexer (\vale\_pygments.py\) for syntax highlighting, and a comprehensive set of reStructuredText (\.rst\) files covering the Vale language syntax, types, expressions, statements, and library interface. The documentation now provides a structured, navigable reference for developers using Vale with Dafny or FStar.

doc/rtd · high confidence

Added two new utility scripts in the tools/scripts directory. The collect-fstar-times.py script aggregates and compares F\* verification times across multiple time files, supporting directory scanning, statistical analysis (average, standard deviation), and diffing between runs. The release.py script automates the creation of binary releases by reading the version from bin/.vale\_version and packaging the bin directory into a zip archive.

tools/scripts · high confidence

The repository is initialized with a new SCons-based build system (SConstruct) that supports verifying code with Dafny and F\*, handling cross-platform execution on Windows, Mac, and Linux, and managing dependencies like Z3 and KreMLin. The project also introduces a build script (build\_local.sh) for local containerized builds, a wrapper script (run\_scons.sh) to invoke SCons across different operating systems, and a Cygwin-specific launcher (scons\_cygwin.sh). Documentation files (README.md, INSTALL.md, CODE.md) and configuration files (.gitattributes, .gitignore, LICENSE) are added to support the new build and development workflow.

(repo-wide) · high confidence

The Vale verification tool has been significantly refactored, introducing a new Abstract Syntax Tree (AST) module (ast.fs) and a dedicated typechecker (typechecker.fs). The build system (SConscript) has been updated to compile the new F\# sources and the DafnyInterface C\# project, which now handles Dafny driver integration. These changes support the new type-checking capabilities for Vale and Dafny files, enabling more robust verification of procedures and operands.

tools/Vale · high confidence

The Dafny toolchain in tools/Dafny has been updated to a new version, introducing updated executables and supporting files. This includes new .NET 4.5 configuration files (Dafny.exe.config, BVD.exe.config, etc.) and manifests for the Visual Studio extension. A new DafnyPrelude.bpl file defines type and axiom structures for the verifier, while DafnyRuntime.cs provides C\# runtime support including immutable Set and MultiSet collections. The update also adds Z3 4.5.0 documentation (Microsoft.Z3.xml) and updated build scripts (PrepareDafnyZip.bat, dafnyBuildVsix.ps1) to package the new components.

tools/Dafny · high confidence

Added Dafny specifications for bit-level and word-level operations; Added F\* specification definitions for word types and boolean monad; Added PowerPC (PPC64LE) and x64 memory copy tests; Added comprehensive test suite for the Vale/F\* integration.

Introduced the Vale tooling project files, including the C\# project file for DafnyInterface and the F\# project file for Vale, which define the build structure and reference local Boogie and Dafny assemblies. Additionally, added a packages.config file to manage the FsLexYacc and FsLexYacc.Runtime NuGet packages, enabling the F\# project to use FsLex and FsYacc for parsing and lexing.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 42 → 44 (+1.5)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 85 → 94 (+9.7)
• Architecture 91 → 93 (+2.2)
• Maturity 39 → 39 (+0.0)
• Readiness 18 → 18 (+0.0)
• Security 96 → 96 (+0.0)

• Dependency hygiene not measured — no packages were read
• Dimension evaluation failed
• Duplicated block (11 lines × 2) (tools/Vale/src/emit_vale_text.fs)
• Duplicated block (13 lines × 2) (tools/Vale/src/emit_vale_text.fs)
• Duplicated block (5 lines × 2) (tools/Vale/src/emit_vale_text.fs)
• Duplicated block (5 lines × 2) (tools/Vale/src/typechecker.fs)
• Duplicated block (6 lines × 2) (tools/Vale/src/emit_fstar_text.fs)
• Duplicated block (6 lines × 2) (tools/Vale/src/transform.fs)
• Duplicated block (6 lines × 2) (tools/Vale/src/typechecker.fs)
• Duplicated block (7 lines × 2) (tools/Vale/src/emit_vale_text.fs)
• Duplicated block (7 lines × 2) (tools/Vale/src/emit_vale_text.fs)
• Duplicated block (9 lines × 2) (tools/Vale/src/emit_vale_text.fs)
• Duplicated block (9 lines × 2) (tools/Vale/src/emit_vale_text.fs)
• High IaC: DS-0009 (.docker/build/windows-nt/Dockerfile)
• No exposed public API
• TooManyMethods: Transform (tools/Vale/src/transform.fs)
• TooManyMethods: TypeChecker (tools/Vale/src/typechecker.fs)
• complexity unreadable for .cs, .fs, .py — churn × complexity hotspots could not be measured
• dormant codebase — no living knowledge left to concentrate

• Documentation: no installation or build instructions (README.md)
• Documentation: no licence statement (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (tools/Vale/src/emit_dafny_text.fs)
• Duplicated block (11 lines × 2) (tools/Vale/src/emit_dafny_text.fs)
• Duplicated block (12 lines × 2) (tools/Vale/src/emit_dafny_text.fs)
• Duplicated block (14 lines × 2) (tools/Vale/src/emit_dafny_text.fs)
• Duplicated block (17 lines × 2) (tools/Vale/src/emit_dafny_text.fs)
• Duplicated block (5 lines × 2) (tools/Vale/src/emit_fstar_text.fs)
• Duplicated block (5 lines × 2) (tools/Vale/src/transform.fs)
• Duplicated block (5 lines × 2) (tools/Vale/src/typechecker.fs)
• Duplicated block (6 lines × 2) (tools/Vale/src/emit_dafny_text.fs)
• Duplicated block (7 lines × 2) (tools/Vale/src/emit_dafny_text.fs)
• Duplicated block (7 lines × 3) (tools/Vale/src/typechecker.fs)
• FileTooLong: Dafny/DafnyRuntime.cs (tools/Dafny/DafnyRuntime.cs)
• High IaC: DS-0009 (.docker/build/windows-nt/Dockerfile)
• High IaC: DS-0009 (.docker/build/windows-nt/Dockerfile)
• High IaC: DS-0009 (.docker/build/windows-nt/Dockerfile)
• High IaC: DS-0009 (.docker/build/windows-nt/Dockerfile)
• Near-duplicate member pair (77 shared lines) (tools/Vale/src/emit_vale_text.fs)
• …and 1 more

• Unchanged — 0 containers · 1 contexts · 0 edges

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

project-everest/vale was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.