darklang/dark

Darklang is a full-stack development platform that provides a custom language, a modular backend runtime, and a comprehensive CLI and IDE tooling. The system enables users to write and execute scripts, manage packages and source control, and interact with external services like HTTP, databases, and AI models. It features a structured capability model for security, a new recursive-descent parser, and extensive tooling including an LSP server and VS Code extension.

40 changes.

This period focused on establishing the foundational infrastructure for the Darklang CLI and VS Code extension. The backend was upgraded to .NET 10 and restructured into modular components, while a new hand-written parser and capability system improved code quality and security. Significant effort was also dedicated to implementing the Language Server Protocol (LSP) to enable robust editor integration and tooling.

34 changes.

This period focused on significantly expanding the Darklang CLI with new commands for package management, script execution, and authentication, alongside a major overhaul of the VS Code extension with virtual document providers and tree views. The backend was refactored to support these features, including a new database layer and configuration system, while comprehensive test coverage was added for language execution and parsing.

49 changes.

This period focused on expanding the Darklang CLI with a comprehensive suite of interactive terminal UI components, source control management tools, and an integrated LLM agent framework. The backend saw significant architectural shifts, including the introduction of binary serialization, the consolidation of built-in functions, and the addition of HTTP server capabilities. Additionally, the platform introduced AI agent capabilities and enhanced package management features.

Introduces a new set of Darklang modules for interacting with the Anthropic Claude API, including model definitions, chat request/response types, content blocks, tool definitions, and batch processing endpoints. The addition includes integration tests that verify direct API calls, token counting, JSON schema structured output, and batch result parsing against the live Anthropic API.

packages/darklang/wip/ai/anthropic · high confidence

A new Branch Manager panel has been added to the VS Code extension, providing a user interface for managing Git branches. Users can now switch, create, delete, and rename branches, as well as perform rebase and merge operations directly from the extension's UI. The panel communicates with the language client to execute these version control actions and displays status messages for success or failure.

vscode-extension/client/src/panels/branchManager · high confidence

Introduces a new \serve\ command in the Darklang CLI that starts an HTTP server backed by a specified router. Users can now configure the listening port (default 8080) and the maximum request body size (default 30 MB) via command-line flags (\--port\ and \--max-body-bytes\). The command parses these arguments, validates them, and executes the server using the standard library's HTTP server utilities.

packages/darklang/cli/http · high confidence

The HTTP server functionality is now exposed as a builtin, allowing users to handle incoming HTTP requests and construct HTTP responses. The implementation includes parsing request headers and bodies, and constructing responses with status codes, headers, and bodies. A key behavioral change is that the HTTP status code is now validated to ensure it fits within the 32-bit integer range; if an out-of-range value is provided, the server returns a 500 error instead of throwing a host exception. The HTTP server module is also reorganized into a new directory structure under \backend/src/Builtins/Builtins.Http.Server\.

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

Added a new set of example scripts in the LLM package that demonstrate various agent configurations and capabilities, including basic text queries, code assistance with file tools, concept explanation with extended thinking, git commit message generation, image description, JSON data extraction, multi-model comparison, news digesting, translation, deep research, and web page summarization.

packages/darklang/llm/examples · high confidence

The LLM module now includes a provider abstraction with implementations for Anthropic, OpenAI, and Ollama. The OpenAI provider supports Azure and custom endpoints, while the Ollama provider defaults to localhost:11434. The Anthropic provider handles Claude API formatting. All providers use Int for token limits and context sizes, and the OpenAI provider supports image URLs and base64-encoded images.

packages/darklang/llm/providers · high confidence

The Language Server Protocol lifecycle is now supported with new files defining the structure for the initialize, initialized, shutdown, and exit messages. This enables the server to properly handle the initial handshake, confirm readiness, and gracefully shut down connections with clients.

packages/darklang/languageServerProtocol/lifecycle · high confidence

The language server now implements several LSP window notifications and requests, enabling richer client-server communication. Specifically, the server can now log messages (window/logMessage), display user-facing messages with action items (window/showMessage and window/showMessageRequest), request to show documents in the client (window/showDocument), and send telemetry events (telemetry/event). These additions support improved logging, user interaction, and diagnostics within the editor.

packages/darklang/languageServerProtocol/window · high confidence

The VS Code extension now includes new Darklang modules for the VS Code API, specifically defining types for TreeItem, TreeItemLabel, TreeItemCollapsibleState, and related structures. These modules provide serialization to JSON, enabling the extension to construct tree view items with properties like labels, collapsible states, commands, and accessibility information for the VS Code UI.

packages/darklang/vscode · high confidence

Added new test files in the backend test suite to verify the execution of basic language features. The changes include \evariable.dark\ for variable scoping and shadowing, \eand.dark\ and \eor.dark\ for logical AND/OR operators with type checking, \estring.dark\ for string interpolation and escape handling, and \dfloat.dark\ for float arithmetic. These tests confirm that the parser and runtime correctly handle variable binding, boolean logic errors, and string formatting.

backend/testfiles/execution/language/basic · high confidence

The CLI now includes an \eval\ command for evaluating Dark expressions (including reading from stdin) and a \run-script\ command for executing Dark script files. Both commands support the \--allow-harmful\ flag to bypass deprecation halts, and the \run-script\ command additionally supports a \--sandbox\ flag to run scripts with no capabilities. Error handling for both commands has been updated to use the new \ExecutionError\ type for structured error reporting.

packages/darklang/cli/execution · high confidence

Introduces a new file-system module for LLM agents, providing read, write, list, and search capabilities. The implementation enforces path safety by preventing directory traversal and absolute paths, and includes a file search feature that scans files for text patterns with configurable result limits.

packages/darklang/llm/tools · high confidence

Users can now run \views\ in the CLI to open an interactive browser for navigating and previewing available terminal dashboards. The \views\ command supports three modes: \views\ opens the interactive browser, \views list\ prints a list of available views, and \views \<name\>\ renders a specific view directly. The \views\ app includes demo data for 'AI Chats' and 'Package Stats' dashboards, each with colorized output, status badges, and keyboard navigation hints.

packages/darklang/cli/apps/views · high confidence

The CLI now includes a new \outliner\ command that provides an interactive, tree-based editor for managing documents. Users can create, rename, and delete documents, as well as edit outline nodes with features like indenting, outdenting, moving, and collapsing tree branches. The tool supports importing and exporting documents in Markdown and OPML formats, and persists state to disk.

packages/darklang/cli/outliner · high confidence

The backend now exposes new built-in functions to inspect the runtime environment. \getAllBuiltinValues\ and \getAllBuiltinFns\ allow users to retrieve lists of all available built-in values and functions, including their descriptions, return types, and parameters. Additionally, the \toRepr\ function has been added to convert any value into its string representation. These tools are implemented in the new \LanguageTools\, \Parser\, and \Reflection\ modules within the backend's built-in library.

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

Users can now interact with Discord webhooks (including rich embeds and mention controls), fetch GitHub release information, handle JSON-RPC 2.0 messages, and manage Tailscale devices directly from Darklang. These new modules provide helper functions and types for building messages, parsing JSON-RPC requests, querying GitHub APIs, and executing Tailscale CLI commands.

packages/darklang · high confidence

New executable scripts are added to the project's linting infrastructure: \scripts/linting/shellchecker\ runs shellcheck on bash/shell scripts while excluding specific directories and ignoring certain rules; \scripts/linting/yamllinter\ runs yamllint on all YAML files, excluding .git, rundir, and backend static/paket-files directories; and \scripts/linting/\_check-linked-libs\ verifies that shared libraries are present for a given binary. These scripts automate and standardize the validation of shell scripts, YAML configuration files, and binary dependencies.

scripts/linting · high confidence

A new \PackageContentProvider\ class has been introduced to handle content for package browsing URLs (e.g., \dark://package/Name.Space.item\). It manages the display of package source code and a placeholder for the package browser, integrating with the language client to fetch file content via the \fileSystem/read\ request.

vscode-extension/client/src/providers/content · high confidence

A new Model Context Protocol (MCP) server has been added to the Feriel package, enabling push notifications through two services: ntfy.sh and Pushover. Users can now send notifications via the 'send\_ntfy\_notification' tool, which requires a topic name and message, or the 'send\_pushover\_notification' tool, which requires environment variables for user key and app token. The server also exposes a status resource and a help prompt to guide users through setup.

packages/feriel · high confidence

The backend now includes new impure builtins for generating random integers and UUIDs. Users can call \int8Random\, \uint8Random\, \int16Random\, \uint16Random\, \int32Random\, \uint32Random\, \int64Random\, and \intRandom\ to get random values within a specified inclusive range. Additionally, \uuidGenerate\ creates a new v4 UUID. All these functions are marked as impure and require the 'random' capability.

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

The Darklang language server now implements the LSP document synchronization protocol, enabling the server to track and manage changes to both standard text documents and interactive notebook documents. This includes handling open, close, and change notifications for text files, as well as opening, closing, and updating notebook documents and their constituent cells. The implementation defines the necessary type structures and JSON serialization logic to support these LSP methods, allowing the editor to maintain an accurate in-memory representation of the user's work.

packages/darklang/languageServerProtocol/documentSync · medium confidence

The Darklang.Opml module was added to provide OPML (Outline Processor Markup Language) export capabilities. This new feature allows users to convert hierarchical node structures into valid OPML XML format, including proper XML escaping for special characters and recursive depth handling for nested lists.

packages/darklang/opml · high confidence

Added new binary serializer modules for the \Capabilities\ type, enabling the serialization of per-instance capability grants that gate effectful builtins. The \Capabilities.fs\ file implements read/write logic for HTTP client/server rules, file/environment/database access scopes, execution rules, and boolean flags for stdout, stdin, random, clock, and LLM access. The \Common.fs\ file provides the low-level binary primitives (varint, string, bool, numeric types, and collection helpers) used by the serializer.

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

The LSP extensions package now includes a new file system provider module that implements read, write, delete, and change notification methods for file system operations. This adds support for interacting with the file system through the Language Server Protocol, enabling features like file content retrieval, modification, and change detection.

packages/darklang/lsp-extensions · high confidence

Two new Bash scripts were added to the scripts/migrations directory: mark-not-run, which deletes entries from the system\_migrations\_v0 table, and new, which generates timestamped SQL migration files in the backend/migrations directory.

scripts/migrations · high confidence

The \stachu\ package now includes a new parser combinator library (\Stachu.Parser\) that provides basic parsing utilities like \regex\, \string\, and combinators such as \andThen\, \orElse\, and \keepLeft\. This library is used to implement a full Darklang parser (\Stachu.DarklangParser\) and a simplified tiny language parser (\Stachu.TinyLang\). Additionally, new modules for JSON handling (\Stachu.Json\) and a JSON Canvas viewer (\Stachu.JsonCanvas\) have been added, along with a temporary implementation for time spans (\Stachu.TimeSpan\).

packages/stachu · high confidence

The repository now includes configuration files to enforce code style and build isolation. A \.dockerignore\ file is added to exclude build artifacts, IDE settings, and local configs from Docker contexts, reducing context size. Editor and language-specific formatting is standardized via \.editorconfig\ (for whitespace and line endings), \.prettierrc.toml\ (for general code formatting), \.style.yapf\ (for Python), and \.fantomasignore\ (to exclude \.dark\ files from F\# formatting). Additionally, a \fsharplint.json\ file introduces linting rules for F\# code, and \.gitattributes\ marks specific test artifacts as generated. These changes ensure consistent formatting and cleaner builds across the monorepo.

(repo-wide) · high confidence

The language server now includes extensive type definitions for multiple LSP features, including call hierarchy, code actions, code lenses, color providers, completions, diagnostics, document highlights, document symbols, find references, folding ranges, formatting, and document links. These additions provide the structural foundation for implementing these LSP capabilities in the Darklang language server.

packages/darklang/languageServerProtocol/language · high confidence

A new F\# module, Builtins.Matter.Builtin, has been introduced to centralize the registration of built-in capabilities. This module aggregates functions for database persistence, package management operations (including packages, branches, rebase, merge, scripts, dependencies, and caps), tracing, and account management. The module also includes a paket.references file specifying dependencies on Ply and FSharp.Core.

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

The CLI standard library now includes dedicated modules for managing shell configurations (Bash, Fish, and PowerShell), allowing users to add aliases and modify PATHs in a cross-platform way. Additionally, a new \Cli.Daemon\ module provides generic background process management, enabling users to start, stop, and monitor detached processes via PID files and log files.

packages/darklang/stdlib/cli · high confidence

The internal dark-packages module now exposes an HTTP router for the package-server endpoints that power wip.darklang.com/packages. The router implements GET endpoints for /ping, /ops, /stats, /search, and various type/value/function lookup routes, along with a POST /ops endpoint for ingesting package operations. A security note indicates that the /ops endpoint currently lacks authentication and should be wrapped in an auth check before public exposure.

packages/darklang/internal/dark-packages · medium confidence

The backend's \Prelude\ directory has been reorganized by extracting specific functionality into separate, dedicated files. This includes new modules for Base64, Dictionary, Exception handling, HashSet, Lazy evaluation, List, Map, NonEmptyList (NEList), NonBlockingConsole, Option, Ply (async/await utilities), Regex, ResizeArray, Result, String, Task, Telemetry, Tuple2, and UTF8 encoding. The main \Prelude.fs\ file now serves as a central hub that re-exports these types and functions, while also introducing compiler warnings to ban the use of \failwith\ and standard \printf\/\printfn\ in favor of the new \Exception\ and \NonBlockingConsole\ modules. This change improves code modularity and makes it easier to find and maintain specific utility functions.

backend/src/Prelude · high confidence

The Darklang language server now includes the foundational types and message parsing logic required to communicate with editors via the Language Server Protocol. This adds support for handling incoming requests and notifications, including document synchronization (open, change, save, close), completions, semantic tokens for syntax highlighting, hover information, and trace logging. The implementation defines the core data structures for LSP messages, enabling the server to parse and route client interactions.

packages/darklang/languageServerProtocol · high confidence

The vscode-extension directory now contains the foundational build and configuration files for the extension. This includes an esbuild bundler script (esbuild.js) that handles TypeScript compilation and SVG asset loading, a TypeScript configuration (tsconfig.json) targeting ES2020 with CommonJS modules, and a language configuration file (language-configuration.json) that defines syntax highlighting rules such as comment delimiters and auto-closing pairs. Additionally, .gitignore and .vscodeignore files are added to manage build artifacts and exclude unnecessary files from the VS Code package.

vscode-extension · high confidence

The \dark caps\ command now includes an interactive terminal UI for editing local capability grants. Users can use \dark caps edit\ to visually manage HTTP, file, environment, database, and execution rules, as well as toggle flags like \random\ or \clock\. The editor supports keyboard navigation, inline editing of rules, and applying preset profiles (e.g., \local-dev\, \read-only\). Changes are written to \\~/.darklang/capabilities.bin\ and enforced by the runtime gate.

packages/darklang/cli/caps · high confidence

Added a new AI agent module for the Dark CLI that enables users to interact with large language models (LLMs) via the command line. The agent supports multiple providers (Anthropic, OpenAI, and local Ollama instances) with configurable models and write modes (read-only, confirm, or allowed). It provides a suite of CLI commands for exploration (tree, search, view), testing (run, eval), and source control (commit, branch, merge), while enforcing safety checks against unsafe characters and unauthorized write operations.

packages/darklang/cli/ai · high confidence

The Darklang CLI now includes a suite of commands for managing source control, including \branch\ (list, create, switch, rename, delete/archive), \commit\ (with support for partial commits via \--include=\), \discard\ (to remove uncommitted changes), \log\ (to view commit history), \merge\ (to merge branches), \rebase\ (to resolve conflicts), \show\ (to inspect specific commits), and \status\ (to view uncommitted changes). These commands allow developers to manage branches, commit code, and track history directly from the command line.

packages/darklang/cli/scm · high confidence

Added Cli.fs, a new module defining builtin functions for building the CLI itself, including script loading, parsing, and error handling. This file introduces the CliTraceSource type for tracing CLI operations and defines the ParseError type for handling parsing failures. The module implements logic to lower a script's source items to a PTCliScriptModule, handling two-pass lowering to resolve sibling references within the same script.

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

The backend now includes a new CliHost module that defines function renames and combines built-in library definitions, alongside a Utils module that implements serialization (to/from Dval) for CLI script modules, including types, values, functions, submodules, and expressions. This change also adds a paket.references file specifying dependencies on Ply, FSharp.Core, Microsoft.Data.Sqlite, and Fumble.

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

A new LibConfig library has been added to the backend, providing a centralized way to read configuration from environment variables. This includes utilities for parsing environment variables into various types (strings, integers, booleans, UUIDs) and managing runtime directories and database names. The library also embeds a build hash for version tracking, falling back to 'dev' for local builds. This change supports the CLI and other entry points by providing adjustable config values with defaults.

backend/src/LibConfig · high confidence

Added a new LocalExec host that enables running local scripts with backend and F\#/dotnet libraries. This includes a CLI entry point (LocalExec.fs) with commands for reloading packages, running database migrations, exporting seeds, and running allocation/timing benchmarks. The implementation introduces new modules for loading packages from disk (LoadPackagesFromDisk.fs), generating package reference hashes (PackageRefsGenerator.fs), and managing SQLite schema migrations (Migrations.fs). Additionally, benchmarking capabilities are added via BenchmarkScenarios.fs and Benchmarks.fs, which measure allocation and timing for blob and stream code paths, with results tracked in JSONL format.

backend/src/LocalExec · high confidence

Adds a new Model Context Protocol (MCP) implementation to Darklang, enabling AI models to communicate with external tools and resources via JSON-RPC. This includes full protocol types for resources, tools, and prompts, along with a server builder API that lets developers register tools, resources, and prompts to create MCP servers.

packages/darklang/modelContextProtocol · high confidence

A new TypeScript interface, PackageNode, has been added to define the structure for representing packages in the extension's tree view. This interface includes properties for identification (id, label), classification (type, with options for owner, module, function, type, or value), and tree state management (children, collapsibleState, contextValue, packagePath).

vscode-extension/client/src/types · high confidence

The VS Code extension is now activated on startup, registering a custom file system provider (darkfs), text document content providers, and file decoration providers. It initializes a Language Server Protocol client to communicate with the Darklang LSP, enabling features like semantic tokens. The extension also introduces a status bar component that displays the current branch and uncommitted changes, alongside tree views for packages and SCM, and panels for the homepage and branch management. Utility functions for HTTP requests and SVG type declarations are also added to support these features.

vscode-extension/client/src · high confidence

A new \dark apps\ command provides a unified interface for discovering, installing, and managing Dark applications. Users can now install foreground apps (which get shell shims) and background daemons (which can be started, stopped, and monitored). The command supports an interactive browser for browsing the full catalog, adding/removing apps, and inspecting daemon status and logs. It also enables auto-starting daemons as OS services on Linux (systemd) and macOS (launchd).

packages/darklang/cli/apps · high confidence

Added new binary serialization modules for package and branch operations, including serializers for package types, values, functions, and operations (add, deprecate, propagate updates, revert). The TypeReference serializer was expanded to support additional types such as TBlob, TStream, and TInt, and the NameResolution module was updated to include an originalName field. These changes enable the system to serialize and deserialize complex package and branch state into a compact binary format.

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

Added new modules for serializing and deserializing runtime (RT) and program (PT) types into a custom binary format. This includes support for Hash, PackageLocation, PackageType, PackageValue, PackageFn, PackageOp, BranchOp, and Toplevel types, enabling efficient binary storage and retrieval of these data structures.

backend/src/LibSerialization/Binary · high confidence

Added binary serialization support for runtime types, including value types, data values, instructions, and package-level functions and types. This enables efficient storage and transmission of runtime type information, supporting features like arbitrary-precision integers, nested function definitions, and content-addressed hashing for packages and commits.

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

The Darklang CLI now supports global installation to the user's home directory (e.g., \~/.darklang/bin) and automatic self-updates from GitHub releases. Users can install the CLI globally, check for updates, and uninstall the global installation. The system detects whether the CLI is running in portable mode or as a global installation, and provides appropriate status and update messages.

packages/darklang/cli/installation · high confidence

Added an internal agent loop implementation that supports multi-turn conversations, tool execution, and extended result data (including thinking, web search results, and citations). The new module defines types for tool outputs, tool calls, and agent configuration, and provides functions to execute tools, process tool calls, and run the agent loop with retry logic. This enables users to build agents that can call external tools and maintain context across turns.

packages/darklang/llm/internal · high confidence

The Darklang internal MCP server is now available to provide AI-assisted development tools, including code execution, function search, type checking, and package listing. It also exposes resources for builtins, standard library, types, configuration, logs, examples, and syntax reference, along with prompts for code review, documentation generation, type conversion, debugging, and pattern matching.

packages/darklang/internal/darklang-internal-mcp-server · high confidence

The SCM package now includes dedicated modules for managing branches (create, list, rename, archive, delete), merging branches with error handling, and handling package operations including WIP tracking, partial commits, and commit history. The Account module provides lookups by name and ID, while the Rebase module handles rebasing branches and detecting conflicts. These changes enable users to create and manage branches, merge changes, and commit work with full traceability.

packages/darklang/scm · high confidence

The parser package now includes dedicated modules for parsing different source constructs: \canvas.dark\ handles module-level declarations (types, values, functions, expressions) for canvas modules; \cliScript.dark\ parses CLI scripts including submodules and generates package operations; \parse.dark\ provides entry points for parsing expressions and source files, including context-aware expression parsing and source file parsing with operations. These modules replace the previous monolithic parser structure with more granular, purpose-built parsing logic.

packages/darklang/languageTools/parser · high confidence

Added new singleton services, PinnedItemsService and RecentItemsService, to manage user preferences for pinned items and recent activity. The PinnedItemsService handles server-synced pinning with optimistic updates and legacy data migration, while the RecentItemsService tracks and persists the last 10 recently accessed items in VS Code's global state, supporting multiple item types like branches, apps, and modules.

vscode-extension/client/src/services · high confidence

Added a new capability system that gates access to effectful builtins (HTTP, file, environment, database, and execution) using structured, per-instance grants. The change introduces \LibExecution.Capabilities\ to define resource-domain axes (e.g., \RW\<string\>\ for file paths, \UrlScope\ for HTTP) and \LibExecution.CapabilityAnalysis\ to compute effective capabilities by walking the function call graph. \LibExecution.CapabilityCheck\ enforces precise, per-call checks against the granted capabilities, ensuring that specific resources (like a particular file path or HTTP host) are explicitly allowed. This replaces the previous unscoped or string-based permission checks with a more granular and auditable model.

backend/src/LibExecution · high confidence

The language tools now include a structured capability model (defined in \capabilities.dark\) that mirrors the F\# \LibExecution.Capabilities\ to control access to effectful built-in functions and external resources. This model defines scopes for HTTP clients, file systems, environment variables, databases, and process execution, allowing the system to enforce security and sandboxing policies. The \common.dark\ file introduces a \BuiltinFunctionPurity\ classification (Pure, ImpurePreviewable, Impure) to categorize built-in functions based on their side effects, which is used by the new capability system to determine if a function can be executed in a restricted context.

packages/darklang/languageTools · high confidence

Users can now run the Darklang CLI as a standalone executable. The CLI embeds a compressed SQLite database and a README, extracting them to a local \.darklang\ directory on first run. It initializes the package manager, grows the database, and executes commands, providing a self-contained environment for running Darklang scripts and managing local state.

backend/src/Cli · high confidence

The VS Code extension now includes new providers that enable editing and viewing of Darklang content through virtual URIs. A new file system provider (darkfs://) allows editing package modules with automatic parsing and operation generation on save, while text content providers (dark://) render source and AST views for packages and branches. Additionally, a diff content provider (darklang-diff://) supports viewing before/after code changes. These providers are backed by a URL pattern router and metadata system that map URL structures to appropriate content sources and file decorations.

vscode-extension/client/src/providers · high confidence

The LSP server implementation has been restructured into new modules: a new \aaaa-state.dark\ defines the \LspState\ and \DocumentInScope\ types; \branches.dark\ adds handlers for creating, deleting, and renaming branches; \completions.dark\ implements autocomplete using the search functionality; \docSync.dark\ manages document synchronization; \diagnostics.dark\ reports syntax and name-resolution errors; \handleIncomingMessage.dark\ routes LSP requests; \hover.dark\ and \hoverInformation.dark\ provide hover details; and \initialize.dark\ sets up server capabilities. This refactoring organizes the LSP server's core functionality into distinct, manageable files.

packages/darklang/languageTools/lsp-server · high confidence

The CLI UI package now includes a comprehensive set of reusable terminal UI components, including buttons, cards, dividers, dropdowns, forms (text input, checkbox, radio, select), labels, layout containers (grid, stack), list views, message/toast/alert notifications, and modals/confirm dialogs. These components provide the foundation for building interactive terminal-based user interfaces.

packages/darklang/cli/ui · high confidence

The CLI runtime now exposes a suite of new built-in functions for interacting with the host system. File operations include \fileRead\, \fileWrite\, \fileDelete\, \fileAppendText\, and \fileExists\/\fileIsDirectory\, all of which require specific file read or write capabilities. Directory operations (\directoryCurrent\, \directoryList\) and environment variable access (\environmentGet\, \environmentGetAll\) are also available, gated by \fileRead\/\envRead\ capabilities. Process execution is handled by \cliExecute\, which runs external commands and returns their exit code, stdout, and stderr. Additionally, \cliGetOS\ identifies the operating system, and \getBuildHash\ returns the CLI build's git hash. Output and terminal control functions (\print\, \printLine\, \stdoutClear\, \debug\) and terminal dimension queries (\cliGetTerminalWidth\, \cliGetTerminalHeight\) have been added to support interactive CLI features.

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

The CLI now includes dedicated commands for managing user identity and local state. The \login\ and \logout\ commands allow users to persist their account session in \cli-config.json\, enabling non-interactive commands to run as a specific user. A new \config\ command provides a way to get, set, and list configuration values, including automatic hints for app ports. Additionally, the \scripts\ command introduces a system for storing, editing, and running saved Darklang scripts, while the \export-seed\ command allows exporting the database to a minimal seed file. These changes restructure the CLI into modular components for better maintainability.

packages/darklang/cli · high confidence

The CLI now includes a suite of new commands for managing and navigating packages. Users can create and edit functions, types, and values directly from the command line using \fn\, \deprecate\, and \delete\ commands. The \db\ command allows listing, viewing, and querying databases. Navigation is enhanced with \nav\ for moving between modules and entities, \back\ to return to the previous location, and an interactive mode for browsing package contents. Additional commands include \ls\ and \tree\ for listing and viewing package structures, \find-values\ to locate values by type, and \hash\ to display content-addressed hashes for items.

packages/darklang/cli/packages · high confidence

The CLI now includes dedicated utility modules for managing terminal output and user interaction. A new \colors.dark\ module provides semantic and standard ANSI color codes for syntax highlighting and UI elements. A \completion.dark\ module introduces an interactive completion picker with icons and descriptions, alongside a robust argument parser (\flagParser.dark\) that supports boolean and value-taking flags with aliases. Additionally, \terminal.dark\ exposes terminal dimensions and viewport calculations, while \logo.dark\ handles ASCII art rendering, and \syntaxHighlighting.dark\ applies semantic token colors to source code.

packages/darklang/cli/utils · high confidence

The backend now includes dedicated builtin modules for HTTP client operations and language processing. The HTTP client builtin aggregates the \Libs.HttpClient\ builtins, while the language builtin combines builtins from \Libs.LanguageTools\, \Libs.Parser\, and \Libs.Reflection\. Both modules are newly added to the codebase, establishing the functional interfaces for these capabilities.

backend/src/Builtins/Builtins.Http.Client, backend/src/Builtins/Builtins.Language · high confidence

The Darklang LLM package now includes a new agent framework that allows users to build AI agents with support for Anthropic, OpenAI, and Ollama providers. Users can create agents, configure models, set system prompts, add tools, and run chat interactions through a unified interface. The framework supports provider-specific features like thinking, web search, JSON mode, and seed control. A model registry provides pre-configured models for each provider, and the system automatically selects a balanced model based on the DARKLANG\_LLM\_PROVIDER environment variable.

packages/darklang/llm · high confidence

The Darklang WIP AI package now includes a comprehensive set of modules for interacting with the OpenAI API. This includes \audio.dark\ for speech-to-text and text-to-speech, \chat.dark\ for chat completions with support for audio output and multi-modal content, \embeddings.dark\ for generating text embeddings, \images.dark\ for image generation and editing, \models.dark\ for listing and managing models, \tools.dark\ for defining function-calling schemas, and \responses.dark\ for the newer Responses API. These modules provide typed interfaces and helper functions to construct requests and parse responses, enabling developers to integrate OpenAI's AI capabilities directly into their applications.

packages/darklang/wip/ai/openai · high confidence

The VS Code extension now displays a Packages tree view that supports pinning items and distinguishes between functions, types, values, and modules with specific icons. Additionally, a new SCM tree view has been added to show uncommitted changes, recent commits, and branch information, allowing users to switch branches and view commit details directly from the sidebar.

vscode-extension/client/src/providers/treeviews · high confidence

A new interactive CLI tool has been added to the SCM package, allowing users to review pending and committed changes to packages across branches. The interface displays a list of branches with uncommitted (WIP) or committed package operations, enabling users to inspect diffs for specific functions, types, and values. This feature provides a structured way to navigate through module groups and view detailed diffs of package changes.

packages/darklang/cli/scm/review · high confidence

The backend now exposes a suite of new builtin functions for the package manager, including \pmCapsGet\/\pmCapsSet\ for managing instance capability grants, \pmScripts\\ for script management, and various \scm\\ and \deps\*\ functions for branch, merge, rebase, and dependency tracking. These additions enable users to manage package state, inspect capabilities, and query dependencies directly through the language's standard library.

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

The VS Code extension now exposes dedicated command handlers for branch management (switch, create, delete, rename, rebase, merge), package/module navigation (look up, open, pin/unpin, reveal in tree), source control operations (status, commit, log, discard, show commit), and script execution (run script with branch context). These commands wire up the VS Code UI to the language client requests, enabling users to manage branches, navigate and pin packages, perform SCM operations, and run scripts directly from the editor.

vscode-extension/client/src/commands · high confidence

Added a new \scripts/formatting/format\ script that provides a unified way to check and format F\# (via Fantomas) and frontend assets (via Prettier) across the Dark project. The script supports \check\ and \format\ modes, with flags to target only F\# or only Prettier files. A corresponding \pre-commit-hook.sh\ is also added to automatically format staged files before committing.

scripts/formatting · high confidence

Added new shell scripts in the scripts/installers directory to handle the installation of .NET, generic executables, and compressed archives (tar.gz, gz, targz). These scripts automate downloading files from specified URLs, verifying their integrity using SHA256 checksums, and placing them in the appropriate system directories, with support for both arm64 and amd64 architectures.

scripts/installers · high confidence

Added several new scripts to the scripts directory: build-and-install-cli-on-host, which builds and installs the Darklang CLI on the host machine; fetch-seed, which downloads and installs the database seed; launch-extension.sh, which sets up the VS Code extension for development; package-extension.sh, which packages the VS Code extension; run-local-exec, which executes local commands within the devcontainer; and updated run-cli, run-backend-server, and run-backend-tests scripts to support the new CLI and extension workflows.

scripts · high confidence

Added new built-in functions for time and system operations: \dateTimeNow\ and \dateTimeToday\ for current datetime retrieval, \timeSleep\ for delaying execution, \timeNowMs\ for monotonic timestamps, and \interpreterStatsReset\/\interpreterStatsGet\ for resetting and retrieving interpreter performance counters and timing statistics.

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

The Darklang tracing package now exposes a formal type system for trace data, including TraceSummary, InputVar, FnCall, and TraceData, which define the structure of recorded executions. Additionally, a new formatting module provides generic helpers for aligning numbers, escaping strings for JSON, and compacting Dval representations, enabling consistent display of trace information across CLI and other consumers.

packages/darklang/tracing · high confidence

The homepage panel has been restructured to include a sidebar navigation with icons for Dashboard, Packages, Docs, Settings, and Changelog, alongside a header bar featuring a user avatar and action buttons. The main content area now renders a dashboard page displaying recent and pinned items, as well as a documentation page with topic listings and content rendering. This change introduces a new component-based architecture for the homepage, separating the header, sidebar, and page content into distinct modules, and integrates services for pinned and recent items.

vscode-extension/client/src/panels/homepage · high confidence

The build system has been reorganized into specialized, reusable scripts to improve maintainability and enable new build capabilities. A new Python-based server builder (\_build-server) and a .NET wrapper (\_dotnet-wrapper) provide a more structured way to compile and run the backend. The compile script has been split into focused components: compile-project handles specific project builds, while compile orchestrates the full build pipeline. A new build-release-cli-exes.sh script enables cross-compilation of the CLI executable for multiple platforms (Linux, macOS, Windows) and supports AOT (Ahead-of-Time) publishing for smaller, faster cold-start binaries. Additionally, build-sqlite.sh handles static linking of SQLite for AOT builds, and clear-builder-volumes/clear-dotnet-build provide targeted cleanup. These changes support a more modular, cross-platform, and optimized build process.

scripts/build · high confidence

The backend's parsing infrastructure has been replaced with a new hand-written recursive-descent parser located in the \LibParser\ module. This new parser produces a range-complete syntax tree that preserves exact source positions for all nodes, enabling improved editor tooling such as syntax highlighting, the LSP, and the code formatter. The change includes a new lexer (\Lexer.fs\) that handles tokenization and trivia (comments), a parser (\Parser.fs\) that builds the \WrittenTypes\ tree, and a name resolver (\NameResolver.fs\) that resolves identifiers against builtins and packages. The old \Parser\ module and its associated files have been removed, and the new \LibParser\ directory now contains the grammar specification (\GRAMMAR.md\), the lexer, parser, and related type definitions (\WrittenTypes.fs\, \WrittenTypesToProgramTypes.fs\).

backend/src/LibParser · high confidence

The standard library now includes new modules for handling JSON parsing and building (AltJson), Base64 encoding/decoding, Blob (binary data) operations, cryptographic hashes (SHA-256, MD5, HMAC), HTTP request/response construction, and CLI user interface components (colors, progress bars, prompts, spinners, tables). These modules wrap existing built-in functions or provide new high-level APIs for common tasks, making it easier to work with external APIs, process binary data, and build interactive command-line tools.

packages/darklang/stdlib · high confidence

A new 'old\_notes' directory was added to the CLI package, containing a README and three Darklang source files (\_command.dark, \_model.dark, \_msg.dark) that define the internal state, command structure, and message types for the CLI. These files represent a collection of stashed, non-production code and design notes, including a 'status' command implementation and the core 'State' model for the CLI interface.

_packages/darklang/cli/old\notes · high confidence

The HTTP server implementation, previously split across multiple files, has been consolidated into a single \HttpServer.fs\ module. This change groups the request handling, header extraction, and response writing logic together, making the HTTP server's behavior easier to understand and maintain.

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

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

backend/testfiles/data · medium confidence · unverified

A .gitkeep file was added to the rundir directory, ensuring the directory is tracked by version control. This supports the organizational change of moving runtime files into a separate directory outside the server.

rundir · low confidence

Added deployment scripts to automate the release process. The new \publish-github-release\ script creates a new GitHub release with uploaded artifacts and, notably, preserves old releases instead of deleting them. The \publish-vs-code-extension\ script checks the current project version against the VS Code Marketplace and publishes the extension only when a newer version is detected.

scripts/deployment · high confidence

The legacy multi-tenant infrastructure code has been consolidated into the new LibCloud module. This includes the Account module for managing developer identities, the Toplevels module for handling user-defined datastores, and the Serialize module for DB serialization. The change also introduces file security checks in the File module and centralizes configuration in the Config module, while the README clarifies that this is legacy code being unwound.

backend/src/LibCloud · high confidence

The CLI builtins are now aggregated in a single module (Builtin.fs) that combines the builtins from various library modules (Directory, Environment, File, Execution, Output, Stdin, Terminal, and Posix). This change simplifies the structure of the CLI by centralizing the registration of built-in functions, making it easier to manage and maintain the available commands and utilities.

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

The devcontainer configuration was restructured into a set of dedicated bash scripts that handle environment initialization, including creating application and cache directories, setting up the Docker network, configuring hostnames for local development, writing environment variables, and managing build server logs. A new SQLite monitor script was added to track database availability.

scripts/devcontainer · high confidence

The HTTP client builtins have been refactored to improve security and observability. The implementation now enforces IP validation to close DNS-rebinding time-of-check-to-time-of-use (TOCTOU) vulnerabilities and ensures the default configuration is safe against Server-Side Request Forgery (SSRF) attacks. Additionally, the streaming HTTP client now supports body parameters, includes body-read timeouts to prevent indefinite hangs, translates stream drain errors into proper network errors, and aligns telemetry spans and tags with the buffered request path for consistent observability.

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

The platform adds a new arbitrary-precision \Int\ type and migrates numerous existing builtins to use it instead of fixed-width integer types. Affected areas include \Blob.length\, \DateTime\ arithmetic, \Dict.size\, \Float\ rounding, \Char\ codepoint conversions, \AltJson\ parsing, and \List\/\String\ indexing and length functions. The change also introduces bitwise operations for the new \Int\ type and updates error handling for integer parsing to use a dedicated \ParseError\ type.

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

The hashing logic has been refactored to use a new canonical serialization format that produces deterministic hashes by skipping identity-irrelevant fields (such as AST node IDs, descriptions, and deprecated flags). This change introduces a \Canonical\ module that handles name resolution and type reference serialization, ensuring that hash computation is stable across different internal representations. The \Hashing\ module now computes SHA-256 hashes of these canonical forms, supporting batch hashing for mutually recursive definitions via a Tarjan's SCC algorithm. This ensures that commits and package items are content-addressed, preventing collisions and improving cacheability.

backend/src/LibSerialization/Hashing · high confidence

The pretty-printing logic for capabilities, runtime errors, and program types has been moved into dedicated Dark files (capabilities.dark, runtimeError.dark, runtimeTypes.dark, programTypes.dark, cliScript.dark, common.dark, and moduleDeclaration.dark). This refactors the F\#-based pretty-printing into the Dark language, providing a single source of truth for rendering capability specs, runtime error segments, and type/value names. Users will see consistent, human-readable output in the CLI and UI, with improved error messages and type name resolution.

packages/darklang/prettyPrinter · high confidence

The DvalReprInternalQueryable module, which handles converting Dvals to/from Sqlite-compatible JSON blobs for internal persistence, has been moved from LibExecution to the new LibSerialization library. This change centralizes serialization logic, separating the JSON representation of data types (including blobs, streams, and all primitive/compound Dval types) from the execution runtime, while maintaining the existing round-trip behavior for database storage.

backend/src/LibSerialization · high confidence

The micro-benchmark suite for Blob/Stream code paths has been moved to the \benchmarks/\ directory at the repository root. The suite now appends each run's snapshot to a tracked \results/history.jsonl\ file, while local artifacts like \results/latest.json\ are gitignored. A \results.md\ file is generated from the JSONL history, and the scenarios are defined in \backend/src/LocalExec/Benchmarks.fs\. This change reorganizes how benchmark data is stored and rendered, shifting from ad-hoc or test-integrated runs to a dedicated, version-controlled history of performance metrics.

benchmarks · high confidence

Added three new .dark script files in the user-code/darklang/scripts directory to support testing and validation. The sample-for-testing-extension.dark file demonstrates support for Float types and literal values, while sample-for-testing-extension.dark and test.dark showcase list constants and record construction. These changes reflect the underlying grammar updates for floats and list constants, providing concrete examples of these new language features.

user-code · high confidence

The language's numeric operators (addition, subtraction, multiplication, division, modulo, and power) are now polymorphic across all numeric types (Int8, Int16, Int32, Int64, Int128, UInt8, UInt16, UInt32, UInt64, UInt128, Float, and BigInt). Integer overflow and underflow now wrap around using two's complement representation rather than raising an error, while integer division by zero and mixed-type operations continue to produce errors. These changes are reflected in the new test files \eapply.dark\ and \einfix.dark\.

backend/testfiles/execution/language/apply · high confidence

The backend's database logic has been consolidated into the new \LibDB\ module, replacing the previous \LibCloud\ and \LibSqlite\ implementations. This change introduces new modules for managing branches, package operations, and name resolution, while removing the old \Handler\ module and \TLHandler\ arm. The refactoring also includes improvements to atomicity for branch operations and the addition of a capability grant system for per-instance access control.

backend/src/LibDB · high confidence

The backend's builtin functions have been reorganized into a new modular structure under the \Builtins.Matter.Libs\ namespace. This change introduces separate modules for account lookups (\Account.fs\), database operations (\DB.fs\), and trace querying (\Traces.fs\). This reorganization improves code maintainability and separation of concerns within the backend's built-in functionality.

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

The database schema was reorganized into a single \schema.sql\ file for the final table definitions, with incremental changes now managed via individual SQL files in the \incremental\ directory. This change fixes a bug where identical package operations on different branches were incorrectly deduplicated due to a composite primary key issue in the \package\_ops\ table. Additionally, the \package\_types\, \package\_values\, and \package\_functions\ tables now include a \description\ column to support searchable package descriptions.

backend/migrations · high confidence

Developers and CI pipelines now use a consistent, standardized configuration format. The \config/dev\ file provides a template for local development settings, while \config/circleci\ defines the environment for CI builds. Both files define key parameters such as database names, HTTP client timeouts, and logging levels, ensuring that local and automated test environments share the same structural conventions.

config · high confidence

The time-related built-in functions are now provided through a unified module that combines the time and date-time libraries, simplifying the structure of the builtins namespace.

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

The serialization artifacts for the oplist-binary-pretty format have been updated. This change reflects the new structure of the serialized output, which now includes additional fields and data types such as Int, char, float, and complex nested structures like NonEmptyList and Result/Option enums. This ensures that the test files accurately represent the current state of the serialization logic.

backend/testfiles/serialization-artifacts · medium confidence

Add comprehensive test suite for the HttpClient; Add database integration tests for records, enums, and nested field access; Add internal test harness for WT/PT conversion; Add test utility modules for expression and value construction; Added CLI integration tests; Added HTTP server test suite; Added HTTP server test suite for demo data; Added comprehensive stdlib test coverage for core modules; Added comprehensive test coverage for all integer types; Added comprehensive test suites for expression handling and shadowing; Added execution tests for if-expressions, pattern matching, and pipe operators; Added interactive CLI test and telemetry viewer; Added regression tests for language tools; Added test cases for Dark language collections (dlist, dtuple, edict); Added test coverage for CLI execution, SCM partial commits, and Tailscale integration; Added test files for custom data types and values; Added tests for the Stachu parser combinator library and a tiny language parser; Expanded execution test coverage for language features; Expanded test coverage for backend components.

The backend build system has been upgraded to target .NET 10 LTS. This update includes a new \Directory.Build.props\ file that sets the target framework to \net10.0\ and configures build output paths, while \global.json\ pins the SDK version to 10.0.102.

backend · high confidence

The backend has been upgraded to .NET 10, with the \paket.dependencies\ file now targeting \net10.0\ and referencing updated packages 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 \Builtins/\ directory (containing \Builtins.Cli\, \Builtins.CliHost\, \Builtins.Http.Client\, \Builtins.Http.Server\, \Builtins.Language\, \Builtins.Matter\, \Builtins.Pure\, \Builtins.Random\, and \Builtins.Time\), alongside new or renamed libraries like \LibCloud\, \LibConfig\, \LibDB\, \LibExecution\, \LibParser\, and \LibSerialization\. The CLI project (\Cli.fsproj\) has been configured for AOT publishing with static SQLite linking and aggressive trimming, while the VS Code extension dependencies have been updated to include \vscode-languageclient\ 7.0.0.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 47.

• Code Health 84
• Architecture 90
• Maturity 43
• Readiness 35
• Security 51
• Domain Modelling 100

• 300 commits — 236 feature/other, 64 fixes

• backend/src — 112 commits
• packages/darklang — 108 commits
• (repo) — 32 commits
• backend/tests — 18 commits
• backend/testfiles — 14 commits
• backend/migrations — 3 commits
• tree-sitter-darklang/test — 3 commits
• (root) — 2 commits
• .circleci/config.yml — 1 commit
• .devcontainer/devcontainer.json — 1 commit
• backend/paket.dependencies — 1 commit
• packages/feriel — 1 commit
• scripts/dev — 1 commit
• scripts/run-backend-server — 1 commit
• scripts/run-backend-tests — 1 commit
• tree-sitter-darklang/src — 1 commit

• fix: Migrate LLM file-search counts to Int and fix provider maxContextTokens
• fix: Add and fix tests
• fix: Add conversions between arbitrary-precision Int and fixed-width integer types
• fix: CLI: fix raw AST dump in error output and introduce typed ExecutionError
• fix: Fix Discord embed color Int64/Int mismatch
• fix: Fix LLM example maxTokens passing Int64 literals to migrated Int param
• fix: Fix capability port conversion build error
• fix: Fix cli docs: Float has no infix operators, point at Stdlib.Float fns
• fix: Fix clipboard paste in the CLI
• fix: Fix corpus tests
• fix: Fix docs signatures resolution and eval help examples
• fix: Fix ephemeral blob lookup failure
• fix: Fix escape handling in parser and pretty-printer
• fix: Fix operator precedence between function application and infix
• fix: Fix package op merge deduplication across branches
• fix: Fix package search to match qualified queries
• fix: Fix tests
• fix: Fix tests
• fix: Fix trace view
• fix: Fix unchecked Int conversions and stale queryability in builtins
• …and 280 more

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

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.