krauthaufen/Adaptify

Adaptify is an F\# compiler tool and runtime library that enables adaptive programming by automatically generating code for mutable, state-managed data structures. It integrates directly into the MSBuild pipeline to analyze F\# types and produce domain-specific code, supporting a wide range of .NET versions from .NET Framework through .NET 10. The system provides core runtime primitives for handling adaptive values, lists, and unions, along with a CLI for local or server-based compilation.

7 changes.

The project underwent significant modernization by upgrading to .NET 8-10 and replacing the legacy FAKE build system with direct dotnet commands. The compiler infrastructure was refactored into modular components with new IPC and caching capabilities, while obsolete F\# compiler core logic and legacy stubs were removed. Concurrently, Adaptify.Core expanded with new attributes and foundational runtime types for adaptive value handling.

4 changes.

This period focused on integrating Adaptify into the MSBuild pipeline via XML-based targets for automated code generation in F\# projects. It also expanded platform coverage by adding examples for .NET 9, .NET Framework, and C\# nested static classes to demonstrate adaptive data handling capabilities.

5 changes.

This period focused on establishing the core Adaptify.Compiler module with initial type analysis, AST handling, and IPC-based compilation logic. It also involved updating the project structure and solution files to support .NET 10, alongside adding integration tests and a new local file generation mode to the CLI tool.

This change introduces new example projects for .NET 8 and .NET 9, alongside a shared library model (\Library.fs\, \Model2.fs\) that defines \ModelType\-annotated records and unions (such as \Thing\, \MyUnion\, and \Soup\) for use with the \Adaptify\ and \FSharp.Data.Adaptive\ libraries. The .NET 9 example program is updated to execute tests against these models, demonstrating adaptive data handling with \AdaptiveSoup\ and change readers, while the .NET 8 example retains a basic setup for unpersisting models. Additionally, the \paket.references\ file for the library example is simplified to depend only on \FSharp.Core\.

src/Examples/Library · high confidence

A new example project targeting .NET Framework has been added to demonstrate the usage of the Adaptify library with F\#. This includes model definitions using the \[\<ModelType\>\] attribute, a program entry point showing unpersisting and updating of adaptive models, and necessary package references.

src/Examples/NetFramework · high confidence

This change introduces the core logic for the Adaptify compiler, including type analysis, AST representation, and project configuration parsing. It adds support for handling adaptive data structures (such as lists, hashmaps, and adaptive values) and defines how properties are treated (e.g., as primary keys, values, or lists). The module also includes a caching system for build artifacts and an IPC-based server for handling compilation requests and messages.

Adaptify.Compiler · high confidence

The \src/Adaptify.Core\ library now includes the foundational runtime types for adaptive programming, specifically \AdaptiveOption\ and \AdaptiveChoice\ (supporting 2- and 3-way discriminated unions) which expose a \Current\ member and handle state transitions via \ShallowEquality\ checks. Additionally, \AdaptiveValue\ provides the base class for computed adaptive values, while helper types like \ChangeableList\ (for arrays and lists) and \ChangeableValueCustomEquality\ enable mutable adaptive state with custom comparison logic. The package references have been updated to include \Aardvark.Build\ alongside \FSharp.Data.Adaptive\.

src/Adaptify.Core · high confidence

The adaptify tool now supports a new --local command-line flag that generates generated files (\*.g.fs) adjacent to the input source files rather than in a separate output directory. This change is accompanied by an updated usage message that documents the new flag alongside existing options like --force, --verbose, and --lenses, and includes a default launch configuration that exercises this new local generation mode.

src/adaptify · high confidence

A new example project located at src/Examples/Net10 has been added to demonstrate support for .NET 10. This includes a new F\# model definition (Model.fs) utilizing the Adaptify library for adaptive data structures, a corresponding entry point (Program.fs), and an updated dependency reference file (paket.references) that now explicitly lists FSharp.Core.

src/Examples/Net10 · high confidence

The \Compiler.fs\ file within \src/Adaptify.Compiler.Core\ has been deleted. This file contained the core logic for analyzing F\# types, handling attributes (such as \Adaptify.ModelTypeAttribute\), and defining AST structures for the compiler. Its removal indicates that this specific F\# compilation and analysis capability is no longer part of the product.

src/Adaptify.Compiler.Core · high confidence

The obsolete \BuildTask.fs\ stub file (containing only a sample 'Hello' module) and the \paket.references\ file listing legacy dependencies (including \FSharp.Compiler.Service\ and \Microsoft.Build\ packages) have been removed from the \src/Adaptify.MSBuild.DotNet\ project. This cleanup eliminates unused code and outdated package references that are no longer required for the current MSBuild integration.

src/Adaptify.MSBuild.DotNet · high confidence

The project now targets .NET 10, enforced by a new global.json file that specifies the SDK version as 10.0.0. The build system has been modernized by removing the legacy FAKE build script (build.fsx) and solution file (Adaptify.sln), replacing them with direct dotnet commands for tool and package restoration and building. A new pack.cmd script has been introduced to handle the packaging of the MSBuild tool and the dotnet tool using aardpack.

(repo-wide) · high confidence

A new example file (CSharpClass.cs) was added to the LibraryCSharp project to demonstrate handling of types within nested static classes, specifically including a nested public class and a nested public struct. This addresses a temporary fix for type handling in nested static classes.

src/Examples/LibraryCSharp · medium confidence

The Adaptify.Compiler project has been restructured from a monolithic Program.fs into distinct modules (CoreTypes, Process, Runner, Scope) to improve maintainability and performance. This change introduces a robust Inter-Process Communication (IPC) layer with file-based locking and TCP support, enabling more stable server-mode operation. It also implements a new caching mechanism that utilizes project hashes and file timestamps to avoid redundant work, and adds a 'local' mode that stores generated files in a user-specific local application data directory rather than the project output folder. Additionally, the Example project and its associated paket.references have been removed.

src/Adaptify.Compiler · high confidence

Adaptify now integrates with the MSBuild pipeline via a new \Adaptify.MSBuild.targets\ file, enabling automatic generation of domain types for F\# projects (\.fsproj\) during compilation. The tool passes configuration arguments via a JSON file to avoid command-line length limits and supports a new \LocalAdaptify\ option to control execution context. It runs before \CoreCompile\, updates the compile item group with generated files, and cleans up intermediate cache files during rebuilds.

src/Adaptify.MSBuild · high confidence

Adaptify.Core now includes new attributes to control how fields and properties are handled by the pre-compiler: PrimaryKeyAttribute marks a field as a primary key, while DefaultEqualsAttribute and CheapEqualsAttribute customize equality comparison logic. Additionally, the TreatAsAListAttribute allows specific fields to be treated as lists. The module also introduces Unpersist, providing a mechanism to define custom initialization and update logic for adaptive values, with built-in support for common collection types like aval, aset, alist, and amap.

Adaptify.Core · high confidence

The project solution files have been reorganized to include support for .NET 10, adding a new Net10 example project alongside existing Net8 and Net9 examples. The solution also reflects the renaming of the core compiler project from Adaptify.Compiler.Core to Adaptify.Compiler and the CLI tool to adaptify, ensuring the build configuration correctly targets these updated project paths.

src · high confidence

Added new test files in src/Tests to verify the Adaptify tool's compatibility across multiple .NET versions. The new ToolTests.fs module includes tests for .NET 8, .NET 9, .NET 10, and .NET Framework, ensuring the tool correctly generates files for each target. Supporting utilities in Utilities.fs provide process execution helpers for running the tool against example projects.

src/Tests · high confidence

Adaptify now targets .NET 8, 9, and 10, replacing the previous .NET Core 2.2 and .NET Standard 2.0 constraints. The .NET tool and MSBuild integration have been updated to use Microsoft.Build 17.11 for .NET 8, 17.14 for .NET 9, and 18.0 for .NET 10, while FSharp.Data.Adaptive has been upgraded to version 1.2.26. The project structure has been reorganized to remove the old Adaptify.Compiler.Core project, and example projects have been updated to demonstrate compatibility with the new .NET versions.

(dependencies) · high confidence

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

• CAI 53 → 53 (-0.6)
• Rubric changed (rubric-2026.09.15 → rubric-2026.10.1) — scores are not directly comparable.

• Code Health 90 → 90 (-0.1)
• Architecture 96 → 100 (+3.8)
• Maturity 34 → 34 (-0.0)
• Readiness 58 → 58 (+0.0)
• Security 75 → 70 (-5.1)

• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Off-boarding risk: anonymized user #1

• Duplicated block (26 lines × 3) (src/Examples/Net10/Model.fs)
• Duplicated block (83 lines × 2) (src/Examples/Net10/Program.fs)
• Off-boarding risk: anonymized user #1

• Unchanged — 0 containers · 2 contexts · 0 edges

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

krauthaufen/Adaptify 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.