Skip to content
CAI
Software that uses CAICheck a score

darklang/dark

55.6

Adequate · 23 October 2026

95k

lines of production code

F#

primary language

6

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

This system is the Darklang runtime and development environment, providing a self-hosted platform for authoring, executing, and managing applications through a custom language and interactive CLI. It features a hand-written parser, a content-addressed package store with branch isolation, and a structured execution model that enforces scoped permissions for effects like HTTP, file I/O, and database access. The system includes a comprehensive standard library, a local SQLite-based store for persistence, and tooling for type-checking, tracing, and performance benchmarking.

How it got here

2016–2023 — Infrastructure modernization and parser rewrite

31 changes.

This period focused on modernizing the project's infrastructure by upgrading to .NET 10, restructuring the backend into modular packages, and establishing robust development workflows with Docker and CI tooling. A major effort involved rewriting the language parser as a hand-written recursive-descent system and introducing a new execution runtime with structured tracing and scoped permissions. The work also included significant improvements to testing coverage, CLI portability, and standard library organization.

2024–2026 — CLI workbench and runtime modernization

70 changes.

This period focused on rebuilding the Darklang CLI into a full-screen interactive Workbench with a new terminal UI framework, while simultaneously rewriting the backend's serialization, SCM, and type-checking systems in the Darklang language. It also introduced a comprehensive POSIX syscall layer, content-addressable storage, and structured tracing to enhance runtime performance, security, and developer debugging capabilities.

Features

Add impure random and UUID generation builtins

New impure builtins have been added to the random library: \int8Random\, \uint8Random\, \int16Random\, \uint16Random\, \int32Random\, \uint32Random\, \int64Random\, \intRandom\, and \uuidGenerate\. These functions allow users to generate random integers within specified inclusive ranges and create new v4 UUIDs. All these operations are marked as impure and require the \Effect.Random\ capability, meaning they will trigger effect-based runtime permissions checks during execution.

backend/src/Builtins/Builtins.Random/Libs · high confidence

Add performance probes for operation costs and CLI workbench rendering

Added a suite of performance probes in \scripts/perf/workloads/probes\ to measure the time and allocation costs of basic Dark operations (such as function calls, record builds, list operations, and equality checks) and to profile the CLI workbench's view rendering and keypress handling. These scripts provide actionable data on where the interpreter spends resources, helping to identify optimization opportunities for the type-checker and runtime.

scripts/perf/workloads/probes · high confidence

Added performance benchmark workloads for core language features

The performance testing suite now includes dedicated workloads for containers (Option/Result), dictionaries, JSON serialization, lists, records/enums, recursion, and strings. These new benchmarks allow users to measure and track the execution cost of specific language constructs, such as pattern matching, functional updates, and text handling, providing deeper insight into interpreter performance beyond the existing list-based control.

scripts/perf/workloads/suite · high confidence

CLI now embeds SQLite and schema, supporting portable and installed modes

The CLI binary now embeds the SQLite database and migration schema, allowing it to function as a self-contained portable executable or an installed tool. It automatically extracts and decompresses the embedded resources on first run, manages local data directories (using \~/.darklang for installed mode or the executable's directory for portable mode), and handles store upgrades with safe backups to prevent data loss during migration failures.

backend/src/Cli · high confidence

Content-addressable hashing with alpha-normalization for stable package identities

The backend now computes SHA-256 hashes of canonical serialized forms to create content-addressable identities for package items. This hashing mechanism ensures meaning-stability by performing alpha-normalization: bound variable names in functions and patterns are renamed to canonical identifiers (e.g., \$0\, \$1\) during a fixed structural traversal, so that two functions identical up to variable renaming produce the same hash. It also supports batch hashing for mutually-recursive definitions using Tarjan's algorithm and treats documentation comments as metadata about content rather than part of the content itself.

backend/src/LibSerialization/Hashing · high confidence

Establish structured benchmark tracking with history and rendering

The repository now includes a dedicated \benchmarks/\ directory that tracks performance data for Blob/Stream code paths. This change introduces a \results/history.jsonl\ file as the single source of truth for benchmark history, alongside a \results.md\ file that is automatically generated by a new \bench-render\ script to display the latest results and a table of past runs. Local experiment snapshots are now gitignored to keep the tracked record clean, and the history has been backfilled with data from previous measurement rounds to provide a continuous performance timeline.

benchmarks · high confidence

Introduce CLI builtins module and dependency references

Added a new Builtin.fs module in the Builtins.Cli project that aggregates built-in functions from various library namespaces (Directory, Environment, File, Execution, Output, Stdin, Terminal, Posix) and defines a function for renaming legacy function names. Also added a paket.references file specifying dependencies on Ply and FSharp.Core.

backend/src/Builtins/Builtins.Cli · high confidence

Introduce CliHost builtin module and utility types

A new CliHost builtin module has been added to define CLI-specific built-in functions and utility types. The module exposes a \builtins\ function that combines CLI-specific builtins with function rename mappings, and defines a \PTCliScriptModule\ type to represent the structure of parsed CLI scripts, including types, values, functions, traits, implementations, submodules, and expressions. Supporting references for Ply, FSharp.Core, Microsoft.Data.Sqlite, and Fumble are also included.

backend/src/Builtins/Builtins.CliHost · high confidence

Introduce Dark-based language tooling and type-checking infrastructure

The \packages/darklang/languageTools\ directory now contains the core implementation of the language server and type-checking logic written in Darklang. This includes a new at-rest type checker that validates code before persistence, a name resolver for cross-package resolution, and a package manager interface. The module also defines the runtime and program types (including support for new integer sizes like Int128/UInt128), a permission system for runtime effects, and utilities for LSP communication and interpreter statistics.

packages/darklang/languageTools · high confidence

Introduce HTTP server builtin for handling requests and responses

This change adds the \Builtins.Http.Server\ module, which provides the core logic for the HTTP server builtins. It includes middleware to parse incoming HTTP requests into the runtime's internal representation (handling URI, headers, and body blobs) and to convert outgoing runtime response records into actual HTTP responses. The implementation enforces lowercase header keys, validates that the status code fits within a 32-bit integer range (returning a 500 error if it does not), and ensures the response body is a blob. It also registers the necessary F\# libraries (Ply, FSharp.Core) for this component.

backend/src/Builtins/Builtins.Http.Server · high confidence

Introduce LibConfig for centralized, environment-backed configuration

A new \LibConfig\ library has been added to manage application configuration via environment variables, providing a consistent way to handle settings across the CLI and server. It includes utilities for parsing environment variables (strings, integers, booleans, UUIDs) with validation, defines runtime directories for logs and databases (defaulting to \data.db\ in the run directory), and implements strict file-access controls to prevent path traversal and other security violations when reading or writing files in specific directories like migrations and test data.

backend/src/LibConfig · high confidence

Introduce LocalExec for local script execution and package management

A new LocalExec module is added to the backend, providing the infrastructure to run local scripts using F\# and .NET libraries. This includes a package loading system that parses \.dark\ files from the \packages/\ directory, resolves names, and stabilizes content-addressed hashes through iterative re-parsing. It also introduces a SQLite-based schema bootstrap mechanism that preserves authored operations during schema changes by dropping and rebuilding projection tables, and adds benchmarking commands to measure allocation and timing for blob and stream operations.

backend/src/LocalExec · high confidence

Introduce hand-written parser and lexer for Darklang source code

The codebase now uses a new hand-written recursive-descent parser and lexer (LibParser) to process Darklang source files, replacing the previous implementation. This new parser produces a range-complete syntax tree (WrittenTypes) that preserves fine-grained source locations for keywords, symbols, and operators, enabling precise syntax highlighting, LSP diagnostics, and lossless source round-tripping. It supports a comprehensive set of language features including arbitrary-precision integers, 8/16/32/64/128-bit signed and unsigned integer types, bitwise operators, power operator (\\), tuple and record access via dot syntax, postfix ? propagation for Result and Option, and multi-level module declarations. The parser includes robust error recovery, returning structured diagnostics with stable codes alongside a best-effort parse tree, and validates structural invariants such as duplicate binders, or-pattern binding consistency, and package declaration rules before lowering to program types.

LibParser · high confidence

Introduce non-empty list type and utilities

A new \NEList\ module has been added to the backend, providing a non-empty list type (\NEList\<'a\>\) along with a comprehensive set of utility functions for iteration, mapping, folding, and manipulation. This allows the application to enforce non-empty constraints at the type level and use specialized operations like \push\, \prependList\, and \splitLast\ that guarantee the resulting collection is never empty.

Prelude · high confidence

Introduce permission profiles and atomic policy editing

Users can now apply predefined permission configurations (profiles) such as 'default', 'read-only', and 'local-dev' to quickly set up access policies for packages. These profiles expand into specific effect rules (e.g., file read/write, HTTP GET, database access) and can be applied atomically. Additionally, instance policy edits are now atomic, ensuring that removals apply before additions to prevent transient permission gaps during updates.

packages/darklang/cli/permissions · high confidence

Introduce the Outliner CLI application

Adds a new interactive tree outliner accessible via the \dark outliner\ command, supporting multi-document management, inline editing, task toggling, search, and undo/redo. The application provides a full-screen terminal UI for interactive use and a set of non-interactive subcommands (\ls\, \show\, \add\, \export\, \import\) for scripting and piping. Documents are persisted to \\~/.darklang/outliner.json\ with versioned storage that automatically migrates data from the previous format, and exports are supported in Markdown and OPML formats.

packages/darklang/cli/outliner · high confidence

Introduce the Workbench: a new interactive CLI interface for Darklang

The \dark\ command now launches the Workbench, a full-screen terminal UI that replaces the previous prompt-based interface. This new interface provides a structured workspace with a branch overview (Home), a package tree browser (Matter), a scratchpad REPL, and an SCM view for managing changes and commits. It features an integrated editor for authoring code, a command bar for quick actions, and real-time live value inspection. The Workbench handles terminal resizing, branch switching, and provides immediate feedback on save operations and permission requirements.

packages/darklang/cli/workbench · high confidence

Introduce unified formatting script and pre-commit hook

A new \scripts/formatting/format\ script centralizes code formatting for F\# (via Fantomas) and web assets (via Prettier), supporting both check and format modes with specific flags for each language. A corresponding \pre-commit-hook.sh\ is provided to automatically check staged files for formatting compliance before committing, ensuring consistent code style across the project.

scripts/formatting · high confidence

New 'serve' command with live-editing and detailed status output

The CLI now includes a \serve\ command that runs an HTTP server using a specified router. Users can configure the TCP port and maximum request body size via flags. A new \--live\ mode allows the server to automatically reload the latest passing version of the router on each request and trigger browser reloads, facilitating live programming workflows. The command provides explicit feedback on the router being used, the port status, and whether live-editing is active, while correctly handling errors for invalid arguments or missing router paths.

packages/darklang/cli/http · high confidence

New CLI app management framework and AI agent capabilities

The Darklang CLI now includes a comprehensive app management system (\dark apps\) allowing users to install, run, and manage foreground apps, background daemons, and live views. This includes an interactive TUI browser for curating the app catalog, automatic OS service registration (systemd/launchd) for daemon auto-start, and PATH shim installation for foreground apps. Additionally, a new AI agent module (\cli/ai/agent\) provides a CLI assistant capable of interacting with the Darklang environment, supporting multiple LLM providers (Anthropic, OpenAI, local Ollama) with configurable write modes and safety checks. Authentication is also enhanced with explicit \login\ and \logout\ commands to manage user sessions for authoring actions.

later/packages/darklang · high confidence

New CLI build, installation, and VS Code extension launch scripts

Added scripts/build-and-install-cli-on-host to build the Darklang CLI from the host machine and install it globally, scripts/launch-extension.sh to start the VS Code extension in debug or release mode, and scripts/package-extension.sh to package the extension into a VSIX file.

scripts · high confidence

New CLI builtin library for script parsing and execution

Added a new \Builtins.CliHost.Libs.Cli\ module that provides the core logic for parsing, validating, and lowering CLI scripts into executable modules. This includes handling source item traversal, two-pass lowering to resolve sibling references, and converting parsed written types into program types for execution.

Builtins.CliHost · high confidence

New CLI commands for backups, builtins, and constraints

The CLI now includes three new commands: \dark backups\ allows users to list, create, restore, and prune local store backups; \dark builtins\ displays available language builtins grouped by type, with optional signature and purity details; and \dark constraints\ reports and manages SCM constraint findings such as stale usages or rival implementations, supporting both human-readable and JSON output for automation.

packages/darklang/cli · high confidence

New CLI commands for branch management, commit history, and conflict resolution

The CLI now includes dedicated commands for source control workflows: \dark branch\ (with subcommands like \switch\, \list\, \merge\, \diff\, and \log\) allows users to manage isolated lines of work, preview merges, and view history; \dark commit\ provides a structured way to review and commit draft changes with support for selective inclusion and type-error handling; \dark commits\ and \dark show\ let users browse commit history and inspect specific commits or operations; \dark conflicts\ enables review of auto-resolved merge or sync conflicts; and \dark deps\ displays dependency and dependent relationships for code items. These changes introduce a more structured, interactive SCM surface within the CLI, replacing or augmenting previous ad-hoc or internal mechanisms.

packages/darklang/cli/scm · high confidence

New CLI commands for expression evaluation and script execution

The CLI now includes dedicated \eval\ and \run\ commands to handle expression evaluation and script execution respectively. The \eval\ command allows users to evaluate Dark expressions directly, supporting multi-line input via stdin (using the \-\ argument) and displaying results in the terminal. The \run\ command executes Dark script files, with support for sandboxed execution (\--sandbox\) and permission warning modes (\--warn-permissions\). It also provides helpful error messages when users attempt to run package functions as scripts, suggesting the correct \eval\ command instead. These changes replace the previous ad-hoc execution paths with a more structured and user-friendly interface.

packages/darklang/cli/execution · high confidence

New CLI installation, update, and status commands

The Darklang CLI now includes a dedicated installation system with new commands: \install\ (to install the CLI globally to \~/.darklang/bin/ or copy the current binary for testing), \update\ (to replace the binary with the latest release, including a smoke test against a copy of your local store), \uninstall\ (to remove the global installation and shell aliases), and \status\ (to show whether the CLI is running in portable or installed mode). The \version\ command now checks for updates by default, with a \--local\ flag to skip the network check. This replaces the previous shell-alias-based setup with a self-contained, cross-platform installer that handles PATH configuration and data migration.

packages/darklang/cli/installation · high confidence

New CLI package authoring and management commands

The CLI now includes a suite of new commands for managing packages directly from the terminal. Users can create and edit functions, values, types, traits, and implementations using \fn\, \val\, \type\, \trait\, and \impl\. A new \edit\ command allows interactive editing of existing items via an external editor or by applying a file. Package lifecycle is managed with \deprecate\ and \delete\ (which refuses deletion if live dependents exist), and \db\ provides commands to list, view, set, get, and delete database entries. Additional utilities include \back\ for navigation history, \find-values\ to locate values by type, and \atRestCheck\ integration to report static type errors during saves.

packages/darklang/cli/packages · high confidence

New CLI standard library builtins for file, directory, environment, process, and terminal operations

The CLI now exposes a comprehensive set of standard library functions for interacting with the host system. Users can read and write files, list and inspect directories, and access environment variables via new \fileRead\, \directoryList\, and \environmentGet\ builtins, all of which return structured error types (e.g., \FileError\) for robust error handling. Process management is enhanced with \cliExecute\ for running commands and \cliSpawnProcess\/\cliProcessIO\ for interactive, long-running subprocesses. Terminal capabilities include \cliTerminalSize\ for layout calculations, \cliTerminalColorEnabled\ for respecting \NO\_COLOR\, and \stdoutCaptureStart\/\stdoutCaptureStop\ for capturing command output in-memory. Additionally, POSIX-specific operations like \posixGetcwd\, \posixChdir\, and \posixMkdir\ are available on Linux and macOS, and input handling now supports paste detection and terminal resize repainting.

backend/src/Builtins/Builtins.Cli/Libs · high confidence

New CLI utility modules for completion, flag parsing, and display

The CLI now includes a set of new utility modules in \packages/darklang/cli/utils\ that enhance command-line interaction. \completion.dark\ provides an interactive tab-completion system with icons and descriptions for commands and filesystem paths. \flagParser.dark\ introduces a shared, declarative argument parser used across CLI commands to handle flags and options consistently. \listing.dark\ adds logic to cap long output lists (like \deps\ and \show\) with a configurable limit and a footer explaining how to see all results, preventing overwhelming output. \glyphs.dark\ standardizes the icons and display order for package items (modules, functions, types, etc.) to ensure consistent alignment and labeling across CLI listings. \syntaxHighlighting.dark\ enables semantic token-based syntax highlighting for source code displayed in the CLI. \terminal.dark\ centralizes terminal size detection, color support, and value rendering options. \logo.dark\ handles the display of the CLI logo with text. \relativeTime.dark\ converts timestamps to human-readable relative times (e.g., "2 hours ago"). \text.dark\ provides shared text formatting helpers for wrapping, short IDs, and pluralization.

packages/darklang/cli/utils · high confidence

New HTTP client builtins with SSRF and bundling protections

Added \httpClientRequest\ and \httpClientStream\ builtins to allow guest code to make HTTP calls. The implementation enforces strict security controls: it blocks requests to private networks unless the caller is a trusted, bundled Darklang package (preventing confused deputy attacks), and validates hostnames to mitigate SSRF and DNS-rebinding vulnerabilities. Users can now fetch remote resources, with options for buffering the entire response or streaming it for large payloads.

backend/src/Builtins/Builtins.Http.Client/Libs · high confidence

New HTTP server implementation with request body limits and response compression

The HTTP server builtin now includes a new \HttpServer\ module that enforces a 30 MB default request body cap to prevent resource exhaustion and supports response compression using Brotli or Gzip when requested by the client. It also automatically injects standard security headers, including HSTS and a 'Server: darklang' identifier, unless explicitly overridden by the application handler.

Builtins.Http.Server · high confidence

New POSIX-based CLI standard library

The CLI standard library has been rewritten to use a new POSIX syscall layer, introducing structured error types (FileError, Posix.Error) and dedicated modules for file, directory, path, process, and shell operations. This change adds support for multiple shells (Bash, Zsh, Fish) with specific configuration helpers, enables per-character stdin reading for interactive prompts, and provides robust file system utilities like recursive directory listing and safe file copying.

packages/darklang/stdlib/cli · high confidence

New SQLite and Tracing builtin libraries

Added new F\# implementation files for the \Builtins.Matter.Libs.Sqlite\ and \Builtins.Matter.Libs.Traces\ modules. The SQLite library exposes primitives (\sqliteExec\, \sqliteQuery\, \sqliteExecBatch\) for direct database access, including parameterized queries and transactional batch execution, while the Traces library provides functions to query the internal trace store, handling binary deserialization of trace data and function call details.

backend/src/Builtins/Builtins.Matter/Libs · high confidence

New dark-packages and GitHub API modules for CLI release management

Added the \Darklang.DarkPackages\ module, which defines a \Stats\ type for tracking package metadata (types, values, functions, traits, implementations, and tests), and the \Darklang.GitHub\ module, which implements interactions with the GitHub API. The GitHub module provides functions to fetch the latest release tag and build hash, determine the correct download URL based on the host's OS and architecture (including specific handling for Linux ARM variants), and parse release assets, supporting the CLI's installation and update mechanisms.

packages/darklang · high confidence

New execution infrastructure: structured tracing, scoped host permissions, and branch identity

The LibExecution layer now introduces a structured execution model that replaces ad-hoc state with explicit, type-safe boundaries. Users benefit from more reliable execution tracing via a new \TraceID\ and \TraceData\ model in \AnalysisTypes\, providing clearer visibility into function calls and inputs. Security and isolation are strengthened by a new \Host\ boundary (\Host.fs\, \HostTypes.fs\) that enforces scoped permissions for file, HTTP, and process operations, ensuring guest code only accesses resources it is explicitly authorized to use. Additionally, a new \BranchId\ type (\Branching.fs\) standardizes branch identity, decoupling it from string names and content hashes to prevent ambiguity in version control operations.

LibExecution · high confidence

New execution runtime modules for blobs, effects, and fast operations

The backend introduces several new core modules in LibExecution to support the rewritten interpreter and permission system. Blob.fs adds content-addressed storage for binary data, handling the promotion of ephemeral blobs to persistent storage via SHA-256 hashing. Effects.fs defines a structured set of runtime effects (such as Http, FileRead, and Native) to gate builtin capabilities and enforce scoped permissions. FastOps.fs implements optimized, direct-path evaluation for common operators (like integer arithmetic and string concatenation) to bypass the standard builtin call overhead. Additionally, Dval.fs and DvalDecoder.fs provide the foundational value representation and decoding utilities, while EffectsToDarkTypes.fs bridges the internal effect model to the Dark language type system.

backend/src/LibExecution · high confidence

New installer scripts for .NET and generic binaries

Added new scripts in the installers directory to handle software installation: install-dotnet installs the .NET SDK with architecture-specific checksum verification, while install-exe-file, install-gz-file, and install-targz-file provide generic mechanisms to download, verify, and install binary files or archives from URLs, supporting both arm64 and amd64 architectures.

scripts/installers · high confidence

New introspection and execution builtins for runtime monitoring and process management

This change introduces several new builtins in the language library to expose runtime internals to users. The \Exec\ module adds process management capabilities, including \spawn\, \await\, and \cancel\, along with a configurable scheduling policy (\exec.policy\) that allows users to define custom process selection logic via a Dark function. The \Instrumentation\ module provides performance monitoring tools, such as \interpreterStatsGet\ for detailed JSON performance counters, \gcAllocatedBytes\ for memory allocation tracking, and \interpreterStatsEnableDetailedTiming\ for per-builtin timing. Additionally, the \LanguageTools\ module exposes metadata about the language itself via \getAllBuiltinValues\, \getAllBuiltinFns\, \getBuiltinFn\, and \getBuiltinValue\, while \Reflection\ adds \toRepr\ for string conversion and \reflect\ for meta-representation of values.

backend/src/Builtins/Builtins.Language/Libs · high confidence

New package manager builtins for store management, testing, and type-checking

This change introduces a new set of package manager (PM) builtins located in the \Builtins.Matter.Libs.PM\ module. Users gain access to \atRestCheckGuarded\ to safely run at-rest type checks without crashing the runtime, and \pmSeedExport\ to export a minimal database seed. Store management is enhanced with \localDbBackupTo\ and \localDbRestoreFrom\ for first-party store snapshots, alongside \localDbPath\ and \storeVersion\ for inspecting the local database state. The package resolution workflow now includes \pmStabilizeHashes\, \pmResolveTraitCalls\, \pmDuplicateDeclarations\, and \pmUnresolvedNames\ to validate and prepare package operations before commit. Additionally, \pmFind{Type,Value,Fn}\ and \pmGetLocationsBy{Type,Value,Fn}\ allow precise lookup of package items by hash or location on specific branches, while \PackageTests\ provides the runtime infrastructure for executing isolated package tests.

backend/src/Builtins/Builtins.Matter/Libs/PM · high confidence

New parser modules for canvas and CLI script handling

The parser package now includes dedicated modules for handling canvas modules (canvas.dark) and CLI scripts (cliScript.dark), alongside core parsing utilities (core.dark, parse.dark). These modules define the data structures and conversion logic (WT to PT) required to parse and process these specific language constructs, including support for traits, implementations, and submodules in CLI scripts, and proper location tracking for canvas entities.

packages/darklang/languageTools/parser · high confidence

New performance measurement and regression-gating tooling

A new \scripts/perf\ directory introduces a suite of tools for measuring and monitoring the Darklang CLI's performance. The \bench\ script provides repeatable CLI timing using byte-identical store fixtures and interleaved A/B comparisons to eliminate noise. The \gate\ script enforces allocation budgets for published builds in CI, ensuring regressions are caught. Additional tools include \suite\ for running a standard set of interpreter workloads, \alloc-profile\ for analyzing allocation hotspots via .NET tracing, \fnprofile\ for ranking function execution times, \http\ for measuring server throughput and latency under concurrency, \keystroke\ for timing interactive CLI redraws, and \first-sync\ for measuring initial data synchronization times.

scripts/perf · high confidence

New pretty-printer package for source reconstruction and disassembly

A new \Darklang.PrettyPrinter\ package has been added to reconstruct Dark source code from internal ProgramTypes and RuntimeTypes structures. It provides \ProgramTypes\ rendering for declarations (types, functions, values, traits, implementations) and expressions, including context-aware name shortening and doc comment formatting. It also includes a runtime instruction disassembler for viewing compiled register-machine code, a structured runtime error segment renderer for readable error messages, and a CLI entry point to print source files with configurable width.

packages/darklang/prettyPrinter · high confidence

New scaffolding and reversion tool for schema migrations

Developers can now use the \scripts/migrations/new\ command to automatically generate paired migration files: a SQL schema file for fresh stores and a corresponding F\# release step for existing stores, ensuring both halves are created together. Additionally, the new \scripts/migrations/mark-not-run\ script allows developers to remove a migration entry from the \system\_migrations\_v0\ table, enabling the re-application of a migration step during development if it has been modified.

scripts/migrations · high confidence

New shell, YAML, and library linting scripts

Added three new executable scripts to the \scripts/linting\ directory to standardize code quality checks: \shellchecker\ runs Shellcheck on all shell scripts (excluding common vendored directories and specific rules), \yamllinter\ validates all YAML files in the repository, and \\_check-linked-libs\ verifies that binaries have all required shared libraries available via \ldd\.

scripts/linting · high confidence

New structured UI component library for the CLI

The CLI UI has been rebuilt around a new, composable component library in \packages/darklang/stdlib/cli/ui\. This introduces a structured \Node\ tree for view definitions, enabling a unified rendering pipeline that supports both terminal output (via \Canvas\ and \Layout\) and HTML export (via \Html\). The library provides reusable, focus-aware components including \Box\ (for framed panes with pill titles), \Chrome\ (for the application frame with title/help bars and status messages), \ListView\ (with a bottom-anchored viewport and scrollbar), \Picker\ (for navigable lists), \Confirm\ (for safe destructive actions), and \Editor\ (for multiline text input). A new \Colors\ module defines semantic styling, and \Layout\ handles region negotiation and span-based rendering, replacing the previous ad-hoc printing approach.

packages/darklang/stdlib/cli/ui · high confidence

New structured tracing system with replay and inspection capabilities

This change introduces a new tracing subsystem for the Darklang runtime, replacing the previous ad-hoc trace values with a structured, persistent record of function calls and execution flow. Users can now record, view, and resume traces via the CLI (\dark traces\), allowing them to inspect inputs, outputs, and call hierarchies for any run (including HTTP requests). The system supports forking traces to experiment with changes without affecting live data, and provides detailed error context for replays, distinguishing between code errors and store drift. This enables deeper debugging and live programming workflows by making execution history queryable and replayable.

packages/darklang/tracing · high confidence

New terminal UI framework with flicker-free rendering

The CLI now includes a new terminal UI (TUI) subsystem that enables interactive, flicker-free interfaces. This framework introduces a pure view model where UI state is represented as data, allowing the renderer to compute minimal diffs between frames and update only changed rows rather than clearing the screen. It supports both fullscreen (alternate screen) and inline modes, handles terminal size changes, and includes robust text measurement and wrapping for wide characters and ANSI styling. This change provides the foundational components for building interactive CLI tools without screen flicker or layout instability.

packages/darklang/stdlib/cli/tui · high confidence

Standard library restructured into typed packages with new capabilities

The standard library has been reorganized from a flat set of builtins into a structured package system (e.g., \Stdlib.Dict\, \Stdlib.Html\, \Stdlib.Blob\), providing type-safe wrappers for previously internal operations. This change introduces new capabilities including programmatic HTML generation with \Stdlib.Html\, binary data handling via \Stdlib.Blob\, and a line-based diffing utility in \Stdlib.Diff\. It also migrates core types like \DateTime\ and \Int\ to use \Int\ instead of \Int64\, replaces string-based error handling with typed enums (e.g., \ParseError\), and adds new functions such as \Dict.setOverridingDuplicates\ and \Float.clampRefusingNaN\.

packages/darklang/stdlib · high confidence

Architecture

Extracted standard library modules into a dedicated Prelude

The backend's standard library functionality has been reorganized into a new \Prelude\ directory, extracting modules for collections (List, Map, HashSet, Dictionary, ResizeArray), utilities (String, Option, Result, Regex, Base64, Lazy), and concurrency (Task, Ply, NonBlockingConsole). This change introduces a non-empty list type (NEList) to prevent empty-list errors, implements iterative sequential helpers for lists and maps to avoid stack overflows on large inputs, and adds a thread-safe, non-blocking console system with capture support for CLI and browser environments. It also includes a lightweight JSON-lines telemetry module for profiling and refines string handling with ordinal case-insensitive comparison and extended grapheme cluster support.

backend/src/Prelude · high confidence

Non-core packages moved to \`later/\` directory

The repository structure has been reorganized by moving all non-core packages into a new root-level \later/\ folder. This change affects the location of several components, including the CLI views (AI Chats, Package Stats, UI Gallery), the Feriel push-notification MCP server, and the Stachu parser and JSON canvas utilities, without altering their internal functionality.

(repo-wide) · high confidence

Reorganized builtins into Matter and Random modules

The builtins system has been restructured into distinct modules to improve separation of concerns. The new Matter module consolidates builtins related to persistence and state, including database operations (UserDB, SQLite), package management (packages, branches, ops, permissions), tracing, and account management. The new Random module groups builtins for UUID generation and random value creation. This reorganization provides a clearer structure for how these core functionalities are exposed and managed within the runtime.

backend/src/Builtins/Builtins.Matter · high confidence

Behavioural changes

3 commits (0 fixes) modifying backend/testfiles/data

A change to existing behaviour in backend/testfiles/data — 3 commits, 6 files.

backend/testfiles/data · medium confidence · unverified

Atomic policy edits and save-time trait call pinning

Users can now atomically edit instance permission policies via new host-only commands (pmPolicySetInstance, pmPolicyEditInstance) that replace or modify allow/deny rules in a single transaction. Additionally, trait method calls are pinned to their specific implementations at save time, ensuring that saved code continues to run against the exact implementation it was written against even if newer versions are deployed later. This pinning is performed by the at-rest checker during the save process, with resolution data decoded from the checker's report and applied to the operations before hashing.

Builtins.Matter · high confidence

Binary format version bump to v6 and canonical hashing updates

The serialization library has advanced its binary format to version 6, introducing support for \PackageTest\ items and the \AddTest\ operation tag. Concurrently, the canonical hashing logic has been refined to ensure deterministic content-addressable storage by explicitly skipping identity-irrelevant fields such as doc comments and AST node IDs, while correctly handling trait implementation choices and strong connection component (SCC) name references to prevent hash collisions.

LibSerialization · high confidence

Creation of dedicated runtime directory

A new 'rundir' directory has been introduced to the project structure, initialized with a .gitkeep file to ensure the directory is tracked by version control. This change establishes a dedicated location for runtime files, separating them from the main server codebase as intended by the move.

rundir · medium confidence

Database schema consolidated into a single initial migration file

The initial database schema has been refactored from fourteen separate numbered SQL files into a single \00-initial-schema.sql\ file. This consolidation simplifies the bootstrap process for new stores by removing the previous numbering system, which was prone to conflicts when multiple branches added files simultaneously. While the mechanism for schema evolution remains unchanged (using \LibDB.Releases\ for existing stores), this change cuts historical compatibility with older store formats that relied on the previous multi-file structure; users must start with a fresh store if upgrading from a version predating this change.

backend/migrations · high confidence

Introduce freestanding native syscall transport for JIT and AOT builds

The backend now includes a new C-based syscall library (syscalls.c) and a build script (build.sh) that compiles a freestanding native transport without libc dependencies. This transport handles low-level kernel operations for supported platforms (Linux x64/arm64/arm and macOS x64/arm64), enabling the interpreter to execute system calls directly via inline assembly. This change replaces previous mechanisms with a unified, platform-specific syscall interface for both Just-In-Time and Ahead-Of-Time compilation targets.

backend/native · high confidence

Introduce typed kernel syscall transport and descriptor-safe POSIX layer

The host execution environment now uses a new typed syscall bridge (HostKernel) to communicate with the kernel, replacing generic libc calls with explicit, checked operations for file I/O, process management, and timing. This is paired with a new descriptor-safe POSIX layer (HostPosix) that manages file descriptors and provides platform-specific implementations for macOS, Linux, and the browser (Wasm), ensuring that guest code interacts with the host through a controlled, type-safe boundary rather than direct native pointers or untyped buffers.

backend/src/LibExecution/Host · high confidence

Introduces custom binary serialization for Dark values with versioned deserialization

The backend now uses a new custom binary serialization format for Dark values, replacing previous methods. This implementation includes version-dispatched deserializers that allow older data blobs to be read by newer builds, ensuring backward compatibility. It also introduces optimized serializers with embedded error handling and specific logic to handle content-addressed operations, such as efficiently determining if an operation binds a name without full decoding.

backend/src/LibSerialization/Binary · high confidence

Language builtins now include reflection and instrumentation capabilities

The Language builtins module has been reorganized to explicitly combine builtins from LanguageTools, Parser, Reflection, Instrumentation, and Exec libraries. This change exposes reflection and instrumentation features as part of the core language runtime, allowing users to inspect and monitor language constructs directly within their code.

backend/src/Builtins/Builtins.Language · high confidence

LibDB refactored into modular components with new caching and validation logic

The LibDB module has been restructured into distinct files (Branches, Caching, Config, DeferredResolver, Deprecations, Docs, Draft, Impl, Inserts, LocalFile, OpValidation) to separate concerns. A new caching system (Caching.fs) provides generation-based invalidation for concurrent lookups. Branch management (Branches.fs) now supports explicit archiving and merging, with improved reference resolution. Op validation (OpValidation.fs) adds pre-write checks for duplicate declarations, hash clashes, and kind conflicts. Deferred resolution (DeferredResolver.fs) handles forward references in package ASTs. Documentation handling (Docs.fs) now supports granular updates to record fields, enum cases, and parameters. Draft operations (Draft.fs) support atomic rebuilds of uncommitted changes. Trait implementation lookups (Impls.fs) are now cached. Local file operations (LocalFile.fs) include security checks against symlink attacks and atomic writes with proper permissions.

backend/src/LibDB · high confidence

New automated release pipeline for CLI and VS Code extension

The deployment scripts now automate the creation of GitHub releases and VS Code extension updates. The \tag-release\ script automatically tags the latest commit on the main branch with a new version (v0.0.N) to trigger builds. The \publish-github-release\ script creates a release from that tag, uploading only the compressed CLI binaries (excluding internal \.mode\ files) and including installation instructions in the release notes, while preserving previous releases. The \publish-vs-code-extension\ script checks the current project version against the marketplace and publishes only if a newer version is detected.

scripts/deployment · high confidence

New binary serialization format for Program Types and Permissions

The backend introduces a new binary serialization format for Program Types (PT) and Permissions, replacing the previous TLHandler-based approach. This new format serializes core program constructs including types (records, enums, aliases), values, functions, traits, and trait implementations, along with their associated metadata like descriptions and type parameters. It also handles expression trees, pattern matching (including wildcards), and name resolution with package locations. Additionally, it serializes permission policies, defining rules for effects, HTTP access, file/DB/env access, and process execution. The format uses content-addressed hashing for packages and commits, supports arbitrary-precision integers (Int128/UInt128) via string encoding, and includes specific handling for special float values (NaN, Infinity). This change ensures a more robust, versioned, and self-describing binary format for these critical backend components.

backend/src/LibSerialization/Binary/Serializers/PT · high confidence

New environment-specific configuration files for CI, development, and local overrides

The repository now includes dedicated configuration files for different execution environments: \config/circleci\ sets up parameters for the CI pipeline (such as disabling test data generation and enabling trace detail), \config/dev\ configures the local development environment (enabling test data generation and setting the package source to disk), and \config/local.template\ provides a template for user-specific local overrides. These files standardize settings for database names, HTTP client timeouts, logging levels, and feature flags across the build and runtime environments.

config · high confidence

New hand-written recursive-descent parser for Darklang source

The backend now uses a new hand-written recursive-descent parser (LibParser) to replace previous tree-sitter and FCS-based parsing. This parser defines a specific surface grammar including support for bitwise operators, exponentiation (\\), and specific integer suffixes, while rejecting anonymous records and requiring \val\ for value declarations. It introduces a new name resolution system that resolves names against builtins and branch-aware package lookups, ensuring cross-package name resolution when packages are parsed. The parser also enforces strict syntax rules such as using commas instead of semicolons for Dicts and Records, and requires separators between collection and field items.

backend/src/LibParser · high confidence

New runtime binary serialization format for packages and values

The backend introduces a new set of binary serializers in the \LibSerialization.Binary.Serializers.RT\ module to handle the persistence and transmission of runtime types, values, and instructions. This change implements the wire format for core data structures including \Dval\ (runtime values), \TypeReference\ and \ValueType\ (type definitions), \PackageFn\ and \PackageType\ (package definitions), and \Instructions\ (executable code). The format supports arbitrary-precision integers (\Int128\/\BigInteger\), traits, streams, blobs, and complex patterns, ensuring that runtime state can be correctly serialized and deserialized across versions.

backend/src/LibSerialization/Binary/Serializers/RT · high confidence

Non-core code moved to later/ directory

Code that is not part of the current product release has been moved to a new \later/\ directory. This includes the VS Code extension source, F\# backend projects, CLI scripts, and various test files. The \later/\ directory preserves the original repository paths, allowing for easy restoration via \git mv\ if needed. The README in \later/\ provides detailed instructions on how to restore these components, including handling of fragments carved out of live files and the necessary steps to rebuild and test them.

later · high confidence

Rebranding of LibBinarySerialization to LibSerialization

The library previously known as LibBinarySerialization has been renamed to LibSerialization. This change reflects the library's role in storing code on disk and producing content-addressable hashes, covering both the binary format for package stores and on-disk caches, as well as deterministic serialization for hashing. The rebranding includes the addition of a README file detailing schema stability rules and safe/unsafe changes for the binary format, and the introduction of a paket.references file specifying FSharp.Core as a dependency.

backend/src/LibSerialization · high confidence

Redesigned devcontainer startup and host configuration

The local development environment now uses a new set of initialization scripts in \scripts/devcontainer\ to streamline container setup. A new \\_post-start\ script automates the creation of necessary application and cache directories, configures Docker socket access, and performs an initial build so the container is ready immediately upon launch. File watching is disabled by default to reduce resource usage, though it can be re-enabled via the \DARK\_DEV\_WATCH\ environment variable. Additionally, \\_setup-hosts\ explicitly registers local development domains (such as \dlio.localhost\, \dark-editor.dlio.localhost\, and \dark-packages.dlio.localhost\) in \/etc/hosts\, ensuring consistent routing for local services.

scripts/devcontainer · high confidence

Redesigned local development workflow with explicit build and watch scripts

The local development experience has been restructured to provide explicit control over building and watching, replacing the previous automatic container-based build-on-save behavior. New scripts in \scripts/dev/\ allow developers to start containers (\start\), trigger synchronous builds (\build\), and manage a background file watcher (\watch\) that is now opt-in rather than automatic. The \start\ script intelligently manages port allocation to prevent conflicts when running multiple local clones, while \status\ and \plan\ provide visibility into build state and pending changes. Additionally, the container attachment process (\\_post-attach\) has been fixed to avoid hanging by only following logs when the watcher is actively running, and a new \host-port\ script simplifies accessing local services.

scripts/dev · high confidence

Refactored LibDB internals for branch isolation, permission analysis, and performance

The LibDB module has been restructured to improve branch isolation, permission analysis, and performance. Branch selection logic is now centralized in \BranchSelection.fs\, supporting flag, environment variable, and stored tiers with automatic degradation to main for archived branches. Permission analysis has been enhanced in \PackagePermissions.fs\ to evaluate transitive effects and purity for list operations, ensuring accurate effect tracking. Performance improvements include \PreparedBatch.fs\ for caching SQLite prepared statements to reduce cold-start overhead, and \HashStabilization.fs\ for SCC-aware content-addressed hashing to handle cyclic dependencies. Additionally, \AstTransformer.fs\ and \Propagation.fs\ now use location-based reference tracking to prevent hash collisions and ensure correct propagation across branches, while \EphemeralPackages.fs\ registers runtime-only declarations for better error reporting.

LibDB · high confidence

Replace capabilities with effect-based runtime permissions

The binary serialization layer for security policies has been rewritten to support an effect-based permission model instead of the previous capabilities system. New serializers in \Permissions.fs\ and \Effects.fs\ handle the versioned binary format for policy files, encoding allow/deny rules for effects, HTTP access, file system access, environment variables, database connections, and process execution. The \Common.fs\ module provides the underlying binary primitives (varints, typed scalars, and collection handling) required to serialize these granular permission scopes and layers (Instance, Run, Package, Function).

backend/src/LibSerialization/Binary/Serializers · high confidence

Replaced legacy compile script with content-aware incremental build system

The build process in scripts/build has been rewritten to use a new Python-based incremental system (\_buildindex, \_buildplan, \_buildstate) that tracks file content hashes instead of relying on timestamps, preventing unnecessary full rebuilds after operations like rebasing or stashing. This system introduces a precise mapping of source changes to specific build actions (such as backend\_full\_build, backend\_quick\_build, and package reloading) and includes a new \_dotnet-wrapper to handle MSB3026 copy errors by killing processes holding output files. Additionally, the release pipeline now supports NativeAOT and ReadyToRun publish modes for the CLI executable, with static SQLite linking via zig cross-compilation to ensure self-contained binaries.

scripts/build · high confidence

Reworked standard library builtins with arbitrary-precision Int and new HTTP client support

The standard library has been reorganized into a modular structure under \Builtins.Pure\, introducing a new arbitrary-precision \Int\ type alongside existing fixed-width integer types (Int8 through Int128). This change brings significant behavioral updates, including the migration of many standard library functions (such as \List\, \String\, \Blob\, and \DateTime\ operations) from \Int64\ to the new \Int\ type, and the introduction of new functions like \Int.remainder\ and \Int.mod\. Additionally, a new \Builtins.Http.Client\ module has been added to support HTTP client operations, and the \AltJson\ library now distinguishes between \Integer\ and \Float\ types to preserve JSON integer precision.

backend/src/Builtins/Builtins.Pure · high confidence

Rewrite of the at-rest type checker in Darklang

The at-rest type checker in \packages/darklang/languageTools/atRestTypeChecker\ has been rewritten in Darklang, replacing the previous implementation. This new checker introduces dedicated modules for coverage analysis (detecting non-exhaustive match patterns), declaration validation (tracking alias cycles and dictionary-key requirements), and trait implementation verification (ensuring implementations match their trait signatures). It also adds a new environment module to load package dependencies and convert builtin metadata, a generation module to turn syntax into solver constraints, and a solver-based model for type inference and constraint solving.

packages/darklang/languageTools/atRestTypeChecker · high confidence

SCM logic rewritten in Darklang with content-addressed commits and typed branch management

The source control module has been migrated from F\# to the Darklang language, introducing a new data model where commits are identified by content-addressed hashes rather than sequential IDs. This change brings typed branch records, explicit merge refusal types, and a dedicated conflict detection system to the Dark layer, while moving account lookups and branch storage into new Dark modules to replace the previous F\# implementations.

packages/darklang/scm · high confidence

Standardize development environment with explicit formatting, linting, and build configuration

The repository now enforces consistent code style and build hygiene through new configuration files. Prettier is configured for general code, Fantomas for F\#, and Yapf for Python, with corresponding linters (yamllint, shellcheck) added to catch issues early. A comprehensive .gitignore and .dockerignore are introduced to exclude build artifacts, IDE settings, and local configs from version control and container builds. The project also adopts the Apache License 2.0, provides a detailed coding guide for contributors, and establishes a robust local development workflow via a Docker-based dev container with explicit build and test scripts.

(repo-wide) · high confidence

Sync transport builtins and credential isolation moved to later/

The backend now includes a set of new builtins in \later/backend\ to support the sync transport: \Stdin.fs.sync\ adds \stdinReadExactly\ for reading fixed-length input frames, and \HttpClient.fs.sync\ introduces five HTTP client functions (\httpGetUnsafeBytes\, \httpGetUnsafeBytesStart\, \httpAwaitBytes\, \httpGetUnsafeBytesWithHeaders\, \httpPostUnsafeBytes\) that operate with SSRF guards disabled but are strictly gated to first-party bundled code via \requireBundledCaller\. \HttpClient.fs.sync-transport\ provides the underlying transport logic, including the confused-deputy check and request handling. Additionally, \Cli.fs.relay-secret\ configures the CLI to attach the relay write secret to requests without exposing it to Dark code, and \Config.fs.credentials\ defines the separate \credentials.db\ file for storing secret-prefixed keys, ensuring they are not readable through the general config API.

later/backend · high confidence

Time builtins reorganized into dedicated module

The time-related built-in functions have been reorganized into a new \Builtins.Time\ module. This change consolidates the time and date-time library integrations (\Libs.Time\ and \Libs.DateTime\) into a single entry point, simplifying how these functionalities are exposed and managed within the backend.

backend/src/Builtins/Builtins.Time · high confidence

Test coverage

Added Dark-side tests for SCM conflict detection and resolution logic; Added HTTP server integration tests; Added HTTP server test handlers and router; Added automated UI testing for the workbench and CLI; Added benchmark scenarios for Blob and Stream performance; Added comprehensive stdlib test suites; Added internal test harness for written-to-program type conversion; Added test coverage for CLI POSIX syscall implementations; Added test suite for HttpClient v0; Added test suite for language features and shadowing behavior; Added tests for CLI stdlib modules; Added tests for language tooling components; Consolidate test utilities into a shared TestUtils module; Expanded CLI test coverage with isolation, golden, and integration tests; Expanded test coverage for backend components; New CI diagnostics and artifact validation tooling; New CLI and parser test infrastructure; New test utility library for interpreter and runtime testing; New testing infrastructure for CI gates and build planning; Ported language tests to package tests.

Dependencies

Backend upgraded to .NET 10 and restructured build configuration

The backend runtime has been upgraded to .NET 10 (SDK 10.0.102), requiring a compatible development environment. To support this and improve build reliability, a centralized \Directory.Build.props\ file was introduced to define shared build properties, including the target framework and parallel compilation flags. Additionally, the build output directory structure was changed to use a relative \Build\ folder, ensuring that build artifacts are correctly isolated and writable regardless of the checkout location, which resolves issues with hardcoded paths in release images.

backend · high confidence

Upgrade to .NET 10 and restructure backend projects

The backend has been upgraded to target .NET 10, introducing dependencies such as FSharp.Core 10.0.100, System.Text.Json 10.0.0, and Microsoft.Data.Sqlite 10.0.0. The project structure has been reorganized into a modular layout under \backend/src/Builtins/\, separating concerns into distinct projects like \Builtins.Cli\, \Builtins.Http.Client\, and \Builtins.Pure\. Additionally, a new \LocalExec\ project has been added to support local execution, and the CLI project now includes configuration for Ahead-of-Time (AOT) compilation and trimming to optimize binary size and startup performance.

(dependencies) · high confidence

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

How this codebase got here

Score

  • CAI 57 → 56 (-1.1)

Lenses

  • Code Health 75 → 76 (+0.5)
  • Architecture 81 → 82 (+0.4)
  • Maturity 58 → 63 (+4.6)
  • Readiness 52 → 53 (+1.7)
  • Security 62 → 64 (+1.7)
  • Accessibility 56 → 49 (-6.7)
  • Performance 94 → 88 (-6.3)

Resolved (149)

  • BranchCommands.register (cognitive 32) (vscode-extension/client/src/commands/branchCommands.ts)
  • BranchCommands.register (cyclomatic 29) (vscode-extension/client/src/commands/branchCommands.ts)
  • BranchManagerPanel.constructor (cognitive 41) (vscode-extension/client/src/panels/branchManager/branchManagerPanel.ts)
  • BranchManagerPanel.constructor (cyclomatic 29) (vscode-extension/client/src/panels/branchManager/branchManagerPanel.ts)
  • Critical IaC: DS-0010 (Dockerfile)
  • Critical IaC: DS-0010 (Dockerfile)
  • Critical IaC: DS-0010 (Dockerfile)
  • DB.fns (cognitive 41) (backend/src/Builtins/Builtins.Matter/Libs/DB.fs)
  • DB.fns (cyclomatic 32) (backend/src/Builtins/Builtins.Matter/Libs/DB.fs)
  • DarkFileSystemProvider.writeFile (cognitive 16) (vscode-extension/client/src/providers/darkFileSystemProvider.ts)
  • Documentation: no architecture or design documentation (README.md)
  • Duplicated block (10 lines × 2) (backend/src/Builtins/Builtins.Matter/Libs/DB.fs)
  • Duplicated block (10 lines × 4) (backend/src/Builtins/Builtins.Pure/Libs/NoModule.fs)
  • Duplicated block (11 lines × 2) (backend/src/Builtins/Builtins.Language/Libs/Exec.fs)
  • Duplicated block (11 lines × 2) (backend/src/Builtins/Builtins.Matter/Libs/PM/PackageOps.fs)
  • Duplicated block (11 lines × 2) (backend/src/Builtins/Builtins.Pure/Libs/Dict.fs)
  • Duplicated block (11 lines × 2) (backend/src/Builtins/Builtins.Pure/Libs/List.fs)
  • Duplicated block (11 lines × 2) (backend/src/Builtins/Builtins.Pure/Libs/List.fs)
  • Duplicated block (11 lines × 2) (backend/src/LibDB/UserDB.fs)
  • Duplicated block (11 lines × 2) (backend/src/LibParser/Parser.fs)
  • …and 129 more

New (124)

  • BranchCommands.register (cognitive 32) (later/vscode-extension/client/src/commands/branchCommands.ts)
  • BranchCommands.register (cyclomatic 29) (later/vscode-extension/client/src/commands/branchCommands.ts)
  • BranchManagerPanel.constructor (cognitive 41) (later/vscode-extension/client/src/panels/branchManager/branchManagerPanel.ts)
  • BranchManagerPanel.constructor (cyclomatic 29) (later/vscode-extension/client/src/panels/branchManager/branchManagerPanel.ts)
  • DarkFileSystemProvider.writeFile (cognitive 16) (later/vscode-extension/client/src/providers/darkFileSystemProvider.ts)
  • Documentation: no installation or build instructions (packages/darklang/cli/installation/README.md)
  • Documentation: no usage examples (packages/darklang/cli/installation/README.md)
  • Duplicated block (10 lines × 2) (backend/src/Builtins/Builtins.Matter/Libs/PM/PackageOps.fs)
  • Duplicated block (10 lines × 2) (backend/src/Builtins/Builtins.Pure/Libs/List.fs)
  • Duplicated block (10 lines × 3) (backend/src/Builtins/Builtins.Matter/Libs/Traces.fs)
  • Duplicated block (10 lines × 3) (backend/src/Builtins/Builtins.Pure/Libs/List.fs)
  • Duplicated block (10 lines × 4) (backend/src/Builtins/Builtins.Pure/Libs/NoModule.fs)
  • Duplicated block (11 lines × 2) (backend/src/Builtins/Builtins.Cli/Libs/Posix.fs)
  • Duplicated block (11 lines × 2) (backend/src/Builtins/Builtins.Pure/Libs/Float.fs)
  • Duplicated block (11 lines × 2) (backend/src/Builtins/Builtins.Pure/Libs/Int64.fs)
  • Duplicated block (11 lines × 2) (backend/src/Builtins/Builtins.Pure/Libs/UInt64.fs)
  • Duplicated block (11 lines × 2) (backend/src/LibParser/Parser.fs)
  • Duplicated block (11 lines × 3) (backend/src/Builtins/Builtins.Pure/Libs/Int16.fs)
  • Duplicated block (11 lines × 3) (backend/src/Builtins/Builtins.Pure/Libs/Int32.fs)
  • Duplicated block (11 lines × 4) (backend/src/Builtins/Builtins.Pure/Libs/Int32.fs)
  • …and 104 more

Changes since last survey

  • 181 commits — 136 feature/other, 45 fixes

By area

  • backend/src — 49 commits
  • (repo) — 42 commits
  • packages/darklang — 36 commits
  • backend/tests — 14 commits
  • .circleci/config.yml — 13 commits
  • (root) — 7 commits
  • backend/testfiles — 4 commits
  • scripts/perf — 4 commits
  • scripts/testing — 4 commits
  • later/backend — 3 commits
  • scripts/vm — 2 commits
  • .circleci/test_artifact_validation.py — 1 commit
  • docs/perf — 1 commit
  • later/packages — 1 commit

Notable commits

  • fix: CI: fix the build cache
  • fix: Checkpoint: harden owned child IO and shared host facts; final regression gates in progress
  • fix: Checkpoint: shared entropy/temp algorithms, runtime inputs and typed path primitives; fix copy regressions
  • fix: Checkpoint: unify unlinkat primitives and fix shared Dark compatibility; strengthen raw host permissions
  • fix: Fix Builtin.mathTanh
  • fix: Fix CLI builds and installation on macOS
  • fix: Fix Dark fnmatch syntax and support package reload outside Docker
  • fix: Fix a hidden dependency on test order in CLI test instances
  • fix: Fix a read in flight grabbing the process's next host call
  • fix: Fix artifact validator cleanup on macOS
  • fix: Fix flaky scheduler tests by waiting up to 30 seconds
  • fix: Fix let-expression regression fixture and format parser changes
  • fix: Fix package loading on fresh stores
  • fix: Fix perf probe gate hanging on a permission prompt in CI
  • fix: Fix race in package reference caching
  • fix: Fix seed preparation before CLI release builds
  • fix: Fix shared errno rendering and retire C-string glob and string flag compatibility
  • fix: Fix shipped-tree typecheck and rebaseline shared StdLib AOT allocation
  • fix: Fix stale answers in the package cache after concurrent edits
  • fix: Fix strict-parser watch regression and verify all 361 CLI checks
  • …and 161 more

Architecture

  • 0 containers · 11 bounded contexts · 24 dependency edges (baseline)

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

Survey your own repository

darklang/dark 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 23 October 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit e76430be5cd9f6b77ed255430dc34a1b58dd8fc4 — the exact code this score is about.
  • Scored under rubric-2026.10.5 — the same rubric and the same method as every other entry in this index.
  • Measured by watchdog.canine.dev using codehealth-analyzer measure-2026.10.6+preprod-d36780c2d857.