Skip to content
CAI
Software that uses CAICheck a score

fslaborg/Deedle

58.0

Adequate · 13 November 2026

26.9k

lines of production code

F#

primary language

8

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Deedle.Parquet component for Apache Parquet read/write support

A new Deedle.Parquet library is introduced, enabling users to read and write Deedle Frames to Apache Parquet files using the Parquet.Net library. This component handles the serialization and deserialization of frame data, mapping .NET types to Parquet DataFields and supporting nullable values for missing data across numeric, boolean, string, and date/time types.

src/Deedle.Parquet · high confidence

Add Excel read and write capabilities for Deedle frames

Users can now read from and write to Excel files (.xls, .xlsx) using Deedle data frames. The new Deedle.ExcelReader library allows reading entire workbooks or specific sheets by name or index into frames, while Deedle.ExcelWriter enables saving frames to single or multiple Excel sheets. These features are exposed via F\# module extensions (e.g., Frame.readExcel, Frame.writeExcel) and static methods for C\# compatibility, relying on ExcelDataReader for reading and MiniExcel for writing.

src/Deedle.ExcelReader · high confidence

Deedle library integration and core data structure implementation

This change introduces the Deedle data analysis library into the project, providing core data structures such as \Frame\ and \Series\ for tabular data manipulation. The implementation includes a purely functional Binomial Heap for efficient minimum-finding operations, a \LinearIndex\ for fast key-based lookups in ordered data, and foundational types like \OptionalValue\ to handle missing data. Additionally, it brings in runtime support from F\# Data, including HTTP client utilities, file system watchers for live updates, and a pluralization service, enabling robust data ingestion and interactive formatting capabilities.

Deedle · high confidence

Initial release of Deedle data frame library

This change introduces the Deedle library, providing a comprehensive data frame and series structure for F\# and C\#. It includes core modules for constructing and manipulating frames (FrameModule, FrameExtensions), handling delayed/lazy data sources (DelayedSeries), and performing statistical operations (FrameStatsExtensions). The library supports reading CSV data from files, streams, and HTTP URLs, and offers extensive functionality for joining, merging, grouping, and reshaping data.

src/Deedle · high confidence

Internal F\# Data runtime components added to Deedle

Deedle now includes internal copies of F\# Data runtime modules (Caching, NameUtils, StructuralInference, StructuralTypes, TextConversions, and TextRuntime) to support its own data provider generation. These additions provide the underlying infrastructure for type inference, text parsing, and caching that Deedle uses internally, marking these F\# Data types as internal to keep them private to the Deedle library.

src/Deedle/FSharp.Data/CommonRuntime · high confidence

Introduce ArrayVector and unified vector builder infrastructure

The library now uses a dedicated \ArrayVector\ implementation to store vector data in continuous memory blocks, automatically switching between dense and sparse representations based on the presence of missing values. A new \IVectorBuilder\ interface and \ArrayVectorBuilder\ provide a unified mechanism for constructing vectors, handling operations like filling missing values, relocating data, and dropping ranges. This change also introduces \VectorData\ types (\DenseList\, \SparseList\, \Sequence\) to expose vector contents efficiently and adds \Vector\ helper modules for F\# and C\# to create vectors from arrays or sequences, simplifying data creation for users.

src/Deedle/Vectors · high confidence

Introduce virtual Parquet reading with lazy column loading

Added \VirtualParquetSource.fs\ to the Deedle.Parquet library, enabling the \Virtual.ReadParquet\ API. This new capability allows users to read Parquet files as virtual frames, where columns are loaded lazily on demand rather than reading the entire file into memory at once. The implementation supports various data types (float, int, string, datetime, etc.) and allows specifying an index column and search columns via \VirtualReadParquetOptions\.

Deedle.Parquet · high confidence

Introduces virtual indexing and hierarchical multi-key support

The library now supports virtual (lazy) indices for DataFrames and Series, allowing operations like merging, slicing, and resampling to work without materializing the underlying data into memory. This is enabled by new \VirtualOrderedIndex\ and \VirtualOrdinalIndex\ implementations in the \Deedle.Indices\ namespace. Additionally, hierarchical multi-key indexing is introduced via \ICustomKey\ and \ICustomLookup\ interfaces, along with helper functions (e.g., \Lookup1Of2\, \LookupAnyOf3\) to match keys at specific levels of tuple-based hierarchies.

src/Deedle/Indices · high confidence

New Apache Arrow integration for Frame and Series I/O

The Deedle.Arrow module now provides direct conversion between Deedle Frames/Series and Apache Arrow RecordBatches, along with functions to read and write Arrow IPC file and stream formats. This enables users to serialize and deserialize Deedle data structures using the high-performance Apache Arrow format, supporting standard numeric types (float, int, uint, bool), strings, and timestamps (DateTime/DateTimeOffset). The implementation maps .NET types to corresponding Arrow types and handles optional values (nulls) during conversion.

src/Deedle.Arrow · high confidence

New Deedle.MicrosoftML package for ML.NET integration

A new \Deedle.MicrosoftML\ package has been added, providing seamless conversion between Deedle Frames and ML.NET \IDataView\. Users can now convert frames to data views using \Frame.toDataView\ and \Frame.ofDataView\, and apply ML.NET transformers or estimators directly to frames via \Pipeline.applyTransformer\, \fitEstimator\, \fitTransform\, and \fitTransformOn\. The implementation supports scalar types (float, float32, int32, int64, bool, string) and fixed-length float32 vector columns, enabling ML.NET pipelines to operate directly on Deedle data structures.

src/Deedle.MicrosoftML · high confidence

Architecture

Introduce internal addressing and range abstractions for BigDeedle

This change adds new internal modules (\Address\, \Ranges\, \Deque\) to the \Deedle.Common\ library to support the BigDeedle architecture. It defines an \Address\ type (based on \int64\) and \IAddressingScheme\ interfaces to decouple index key mapping from vector storage, allowing for different addressing schemes like partitioned offsets. It also introduces \RangeRestriction\ types and a \Ranges\<'T\>\ abstraction to efficiently manage sub-ranges of ordinal indices, enabling optimizations for slicing and merging operations without fully materializing data. A new \Deque\ implementation provides a fast, mutable double-ended queue for internal statistical calculations.

src/Deedle/Common · high confidence

Repository infrastructure and build system overhaul

The repository has been restructured with new configuration files to standardize development and build processes. An \.editorconfig\ enforces 2-space indentation for F\# and XML files. A new \Directory.Build.props\ centralizes versioning by parsing \RELEASE\_NOTES.md\, enables SourceLink for debuggable NuGet packages, and configures deterministic builds in CI. The solution file (\Deedle.sln\) has been updated to include new projects such as \Deedle.Arrow\, \Deedle.Parquet\, \Deedle.ExcelReader\, \Deedle.ExcelWriter\, and \Deedle.MicrosoftML\. Build scripts (\build.sh\, \build.ps1\) now use Paket for dependency management and fsdocs for documentation, while \global.json\ targets the .NET 10 SDK. Documentation and contribution guidelines have been added via \AGENTS.md\ and \CONTRIBUTING.md\.

(repo-wide) · high confidence

Behavioural changes

2 commits (0 fixes) modifying misc

A change to existing behaviour in misc — 2 commits, 2 files: “Finish ranges and lazy loading”; “Updated logo”.

misc · medium confidence · unverified

Internal CSV parsing engine added to Deedle

Deedle now includes its own internal implementation of the F\# Data CSV runtime components (CsvFile, CsvRow, CsvReader, and CsvInference) within the src/Deedle/FSharp.Data/Csv directory. This change embeds the CSV parsing, schema inference, and type-provider logic directly into the library, marking these types as internal to Deedle rather than relying on an external F\# Data package reference. Users can continue to use existing CSV loading and parsing APIs, but the underlying engine is now part of Deedle's own codebase.

src/Deedle/FSharp.Data/Csv · high confidence

Rename Deedle.Math namespace to Deedle.MathNetNumerics

The Deedle.Math namespace has been renamed to Deedle.MathNetNumerics to better reflect its dependency on the MathNet.Numerics library. All core modules (Frame, Series, LinearAlgebra, Stats, Finance, etc.) are now located under the new namespace. The old Deedle.Math namespace is preserved as a deprecated shim that redirects to the new types, ensuring existing code continues to compile with warnings. Users should update their open statements and type references from Deedle.Math to Deedle.MathNetNumerics.

Deedle.MathNetNumerics, src/Deedle.MathNetNumerics · high confidence

Test coverage

Add BenchmarkDotNet performance benchmark suite; Added C\# test coverage for Deedle core, Arrow, Parquet, and Excel readers; Added comprehensive test suite for Frame operations and virtual data structures; Added test infrastructure and sample data generation for Arrow and Parquet modules; Added test infrastructure for virtual data sources and instrumentation; Added test suite for Deedle.Arrow IPC I/O and type conversions; Added test suite for Deedle.MathNetNumerics integration; Added test suite for Deedle.Parquet round-trip and type support; Added tests for Deedle ExcelReader functionality; Added tests for Deedle.MicrosoftML integration; Added virtual preservation tests and Parquet test data; Expanded test coverage for Deedle core components; Updated performance test assets and results for versions 0.9.12, 1.0.0, and 1.1.1-beta.

Dependencies

Upgrade to .NET 10 and update core dependencies

The project has been upgraded to target .NET 10.0 across all source and test projects. Key dependency updates include FSharp.Core to version 10.1.201, FSharp.Data to 8.1.4, MathNet.Numerics to 5.0, and NUnit to version 4 (with FsUnit 7.1.1). The dependency management system has been standardized on Paket, introducing a new paket.dependencies file and lockfile to manage packages such as Apache.Arrow, Parquet.Net, and BenchmarkDotNet.

(dependencies) · high confidence

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

How this codebase got here

Score

  • CAI 47 → 58 (+10.8)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.

Lenses

  • Code Health 33 → 65 (+31.8)
  • Architecture 56 → 56 (-0.2)
  • Maturity 68 → 60 (-8.8)
  • Readiness 56 → 56 (+0.0)
  • Security 67 → 59 (-8.2)
  • Performance 82 → 97 (+15.2)

Resolved (62)

  • AnalyzerSeverityNone repeated across 21 files (packages/Microsoft.CodeAnalysis.Analyzers/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
  • AnalyzerSeverityNone repeated across 21 files (packages/Microsoft.CodeAnalysis.Analyzers/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
  • AnalyzerSeverityNone repeated across 21 files (packages/Microsoft.CodeAnalysis.Analyzers/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
  • AnalyzerSeverityNone repeated across 21 files (packages/Microsoft.CodeAnalysis.Analyzers/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
  • AnalyzerSeverityNone repeated across 21 files (packages/Microsoft.CodeAnalysis.Analyzers/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
  • AnalyzerSeverityNone repeated across 21 files (packages/Microsoft.CodeAnalysis.Analyzers/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
  • AnalyzerSeverityNone repeated across 21 files (packages/Microsoft.CodeAnalysis.Analyzers/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
  • AnalyzerSeverityNone repeated across 21 files (packages/Microsoft.CodeAnalysis.Analyzers/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
  • AnalyzerSeverityNone repeated across 21 files (packages/Microsoft.CodeAnalysis.Analyzers/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
  • AnalyzerSeverityNone repeated across 21 files (packages/Microsoft.CodeAnalysis.Analyzers/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
  • AnalyzerSeverityNone repeated across 21 files (packages/Microsoft.CodeAnalysis.Analyzers/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
  • AnalyzerSeverityNone repeated across 21 files (packages/Microsoft.CodeAnalysis.Analyzers/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
  • AnalyzerSeverityNone repeated across 21 files (packages/Microsoft.CodeAnalysis.Analyzers/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
  • AnalyzerSeverityNone repeated across 21 files (packages/Microsoft.CodeAnalysis.Analyzers/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
  • AnalyzerSeverityNone repeated across 21 files (packages/Microsoft.CodeAnalysis.Analyzers/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
  • AnalyzerSeverityNone repeated across 21 files (packages/Microsoft.CodeAnalysis.Analyzers/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
  • AnalyzerSeverityNone repeated across 21 files (packages/Microsoft.CodeAnalysis.Analyzers/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
  • AnalyzerSeverityNone repeated across 21 files (packages/Microsoft.CodeAnalysis.Analyzers/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
  • AnalyzerSeverityNone repeated across 21 files (packages/Microsoft.CodeAnalysis.Analyzers/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
  • AnalyzerSeverityNone repeated across 21 files (packages/Microsoft.CodeAnalysis.Analyzers/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
  • …and 42 more

New (13)

  • Concentrated knowledge decay
  • Duplicated block (11 lines × 10) (src/Deedle.Parquet/Parquet.fs)
  • Most significant orphaned file (src/Deedle/FSharp.Data/Net/Http.fs)
  • Most significant orphaned file (src/Deedle/Vectors/VirtualVector.fs)
  • Most significant orphaned file (src/Deedle/VirtualFrame.fs)
  • Orphaned file (src/Deedle/Common/Address.fs)
  • Orphaned file (src/Deedle/Indices/VirtualIndex.fs)
  • Orphaned file (src/Deedle/Vectors/ArrayVector.fs)
  • Outdated: Azure.Core
  • Outdated: Iced
  • Outdated: Microsoft.IO.RecyclableMemoryStream
  • Outdated: MiniExcel
  • Outdated: System.ClientModel

Changes since last survey

  • 3 commits — 3 feature/other, 0 fixes

By area

  • .github/aw — 2 commits
  • .github/workflows — 1 commit

Notable commits

  • change: update repo assist
  • change: update repo assist
  • change: update repo assist

Architecture

  • Unchanged — 0 containers · 6 contexts · 5 edges

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

Survey your own repository

fslaborg/Deedle 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.

About this page

  • The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit eaa64bdc867b7367594247f79cb223ef19ab10da — the exact code this score is about.
  • Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.61+preprod-b8b1a43ae4c3.