elixir-lang/elixir

This system is the Elixir programming language runtime and its associated standard tooling, encompassing the core language implementation, the Mix build tool, the IEx interactive shell, and the ExUnit testing framework. It provides capabilities for compiling and running Elixir code, managing project dependencies and releases, formatting source code, and executing unit tests with detailed reporting. The system also includes utilities for logging, template rendering, and interactive debugging, all integrated with Erlang/OTP infrastructure.

38 changes.

This period focused on modernizing Elixir's core infrastructure by introducing standardized project configuration, enforcing stricter encapsulation in the compiler, and requiring Erlang/OTP 24. Significant architectural shifts included extracting IEx into a standalone OTP application, restructuring ExUnit for better maintainability, and implementing Mix.install for runtime dependency management. These changes were accompanied by extensive test coverage expansion and the addition of developer-friendly features like EEx indentation support and IEx pry debugging.

37 changes.

This period focused on modernizing Elixir's core libraries by integrating with Erlang/OTP 21's native :logger, replacing gen\_event with GenServer-based agents, and introducing protocols like String.Chars. Significant architectural overhauls were applied to Mix's compiler and dependency management systems to improve performance and maintainability, while extensive test coverage was added to support these structural changes.

30 changes.

This period focused on a major architectural overhaul of the compiler's type checking system, replacing the previous implementation with a set-theoretic approach using Binary Decision Diagrams for improved precision and performance. Concurrently, the project expanded its developer tooling by introducing dedicated modules for code formatting and normalization, unifying installation logic in Mix, and adding comprehensive manual pages and documentation generation scripts. These core changes were supported by extensive test coverage additions and infrastructure improvements, such as parallel verification and release configuration providers.

5 changes.

This period focused on establishing a new cross-process concurrency locking and pub/sub infrastructure within Mix to support coordinated operations across multiple OS processes. Concurrently, the project introduced initial OSS Review Toolkit configuration to enforce license compliance and generate Software Bill of Materials, while expanding test coverage for macro environment functions and registry key modes.

This change introduces new manual pages (man pages) for the core Elixir command-line tools: \elixir\, \iex\, \mix\, and \elixirc\, along with a shared \common\ options file. Users can now consult these pages to understand command-line options, environment variables (such as \MIX\_ENV\, \MIX\_DEBUG\, and \ELIXIR\_ERL\_OPTIONS\), and file structures for each tool. The documentation covers common flags like \-eval\ and \-rpc-eval\, specific compiler options for \elixirc\, and project management features for \mix\.

man · high confidence

The ExUnit testing framework is now available in the \lib/ex\_unit/lib\ directory, providing the core module for unit testing in Elixir. This change introduces the main \ExUnit\ module which defines the configuration options (\configure\_opts/0\), test states, and result structures. Users can now start the test runner via \ExUnit.start/0\ and configure behaviors such as test timeouts, color output, filtering, and formatter selection through the defined configuration schema.

_lib/ex\unit/lib · high confidence

IEx now integrates with Kernel.dbg/2, allowing developers to pause code execution and inspect variables, imports, and aliases at runtime. To use this feature, start IEx with the --dbg pry flag (e.g., iex --dbg pry -S mix). When dbg is encountered, IEx will ask for permission to enter a pry session, enabling interactive inspection without modifying the running code or accessing private functions. This provides a powerful debugging workflow directly within the interactive shell.

lib/iex/lib · high confidence

This change introduces the initial configuration for the OSS Review Toolkit (ORT) to enforce open-source policy and generate Software Bill of Materials (SBoM). It adds ORT configuration files that enable repository package curations and configurations, configure the scanner to include files without findings, and set up the analyzer to process SPDX documents. The entry includes evaluator rules that define whitelisted licenses (such as Apache-2.0 and specific Elixir trademark policies) and establish rules to flag unhandled or unmapped licenses. Additionally, it provides package-specific configurations for core components like \elixir\, \eex\, \ex\_unit\, \logger\, and \mix\ to exclude test files, documentation, and build tools from license scanning, and to curate license findings for logos, test fixtures, and unicode files.

.ort · high confidence

Elixir now includes the \Config.Provider\ behaviour and \Config.Reader\ implementation, enabling users to load external configuration files during the system boot process in releases. This allows for flexible runtime configuration strategies, such as loading settings from JSON files or other external sources, by defining custom providers or using the built-in reader to merge additional config files into the application's environment.

lib/elixir/lib/config · high confidence

The project now includes a set of standardized configuration files to manage formatting, linting, and build metadata. A new \.formatter.exs\ defines the Elixir code formatter inputs and local function rules, while \.markdownlint-cli2.jsonc\ configures markdown linting rules for documentation. Build and repository metadata are standardized with \.gitattributes\ for line endings and diff drivers, a comprehensive \.gitignore\ for build artifacts, and \.ort.yml\ for Open Source Toolkit license scanning and curation.

(repo-wide) · high confidence

The \List.Chars\ protocol has been added to standardize the conversion of various data types into charlists. This new protocol defines the \to\_charlist/1\ function and provides default implementations for core Elixir types including Atoms, BitStrings, Lists, Integers, and Floats, allowing these structures to be seamlessly converted to charlists via the \Kernel.to\_charlist/1\ function.

lib/elixir/lib/list · high confidence

The Mix module now includes the \Mix.install/2\ function, allowing users to install and load dependencies at runtime without needing a pre-existing project structure or \mix.exs\ file. This feature enables scripting and interactive usage of external libraries directly from the command line or IEx, supporting options for configuration, environment variables, and protocol consolidation. It also introduces \Mix.installed?/0\ to check if dependencies have been installed and provides mechanisms to manage the installation directory and force reinstallation.

lib/mix/lib · high confidence

Added two new documentation cheatsheets to the Elixir docs: a comprehensive reference for the \Enum\ module covering predicates, filtering, mapping, and comprehensions, and a guide to set-theoretic type syntax including operators, data types, and map key specifications.

lib/elixir/pages/cheatsheets · high confidence

Added two new example scripts, \lib/ex\_unit/examples/difference.exs\ and \lib/ex\_unit/examples/one\_of\_each.exs\, to demonstrate ExUnit's failure reporting capabilities. The \difference.exs\ script contains failing assertions for various data types (integers, floats, strings, lists, maps, structs, etc.) to showcase the new difference highlighting features, including whitespace visualization and inner-diff support. The \one\_of\_each.exs\ script provides a comprehensive catalog of all ExUnit assertion and refute variants (including \assert\_receive\, \assert\_raise\, \assert\_in\_delta\, and linked/trapped exit handling) to document the specific output style for each failure mode.

_lib/ex\unit/examples · high confidence

This change introduces two new modules to the IO library. IO.ANSI provides functionality to render ANSI escape sequences for controlling terminal formatting, color, and output options, including support for 256-color and RGB color modes, various text attributes (bold, italic, underline, etc.), and a high-level format/1 API that automatically handles ANSI enablement checks. IO.Stream defines a struct and implementations for the Enumerable and Collectable protocols, allowing IO devices to be treated as streams for reading lines or bytes and writing data, with support for both raw binary and character modes.

lib/elixir/lib/io · high confidence

The \IO.ANSI.Docs\ module has been introduced to handle the formatting and display of documentation within the IEx shell. This new component provides structured rendering for Markdown content, including support for headings, code blocks, quotes, and metadata (such as deprecation notices and guard clauses). It allows users to view richer, color-coded documentation directly in the interactive shell, replacing previous ad-hoc or less structured printing methods.

lib/elixir/lib/io/ansi · high confidence

A new Mix.Shell.Quiet module has been added to suppress informational output when the MIX\_QUIET environment variable is set. It delegates most operations to Mix.Shell.IO but overrides info/1 to print nothing and cmd/2 to execute commands without streaming output, allowing users to run Mix tasks with significantly reduced console noise.

lib/mix/lib/mix/shell · high confidence

The \lib/elixir/lib/record/extractor.ex\ module has been added to provide programmatic extraction of Erlang record definitions. It exposes \extract/2\ and \extract\_all/1\ functions that parse Erlang source files (supporting both \:from\ and \:from\_lib\ options) to retrieve record names and their field default values. This implementation leverages Erlang's \:epp\ for macro expansion and \:erl\_expand\_records\ for parsing, allowing Elixir code to introspect Erlang record structures directly.

lib/elixir/lib/record · high confidence

Mix now includes a new synchronization layer in \lib/mix/sync\ that enables coordination across multiple OS processes. This introduces a filesystem-based lock implementation (\Mix.Sync.Lock\) using TCP sockets and hard links, which can be disabled via the \MIX\_OS\_CONCURRENCY\_LOCK\ environment variable. It also adds a TCP-based pub/sub system (\Mix.Sync.PubSub\) for inter-process communication and a \Mix.PubSub.Subscriber\ GenServer to accumulate and flush messages. These components provide the foundation for listening to concurrent mix compilations and improving user detection in lock and pub/sub operations.

lib/mix/lib/mix/sync · high confidence

The \lib/elixir/scripts\ directory now contains several new internal tooling scripts that change how the Elixir project is tested, built, and documented. \cover.exs\ and \cover\_record.exs\ implement a new test coverage reporting mechanism that collects and combines coverage data from ExUnit suites, allowing developers to generate coverage reports. \diff.exs\ adds utilities for comparing build artifacts, specifically providing human-friendly diffs for BEAM files to aid in verifying deterministic builds. Additionally, \docs\_config.exs\, \elixir\_docs.exs\, and \mix\_docs.exs\ configure and generate documentation, introducing support for Markdown and ePUB formats, integrating Mermaid diagrams for visualizations, and setting up version-specific documentation hosting via HexDocs.

lib/elixir/scripts · high confidence

Elixir introduces a new type checking system and parallel verification engine to improve compile-time diagnostics. A new \Module.Behaviour\ module handles validation of \@behaviour\ and \@impl\ attributes, ensuring callbacks are correctly defined and implemented. The \Module.ParallelChecker\ module provides a concurrent verification process that checks modules in parallel, optimizing compilation performance and handling cache lookups for BEAM files. Additionally, \Module.Types\ implements type inference and signature generation, allowing the compiler to automatically infer return types for functions and detect unused private definitions. These changes shift type-related logic from the core compiler into dedicated modules, enabling more precise error reporting and faster compilation through parallelization.

lib/elixir/lib/module · high confidence

Elixir now provides an offline Windows installer that verifies the presence and version of Erlang/OTP before proceeding, guiding users to download the correct Erlang version if missing or mismatched. The installer allows users to optionally add both the Elixir and Erlang/OTP binary directories to their system PATH via a dedicated Erlang script that updates the Windows registry, and it includes a build script to generate the installer from precompiled archives.

_lib/elixir/scripts/windows\installer · high confidence

The ExUnit test framework implementation has been reorganized into distinct, dedicated module files (such as assertions.ex, callbacks.ex, and capture\_io.ex) replacing the previous monolithic structure. This change improves code maintainability and clarity by separating assertion logic, lifecycle callbacks, and IO capture functionality into their own modules, while preserving the existing public API and behavior for users writing tests.

_lib/ex\_unit/lib/ex\unit · high confidence

The IEx interactive shell has been restructured into a standalone OTP application (lib/iex/lib/iex). It now includes a dedicated application module (IEx.App) that starts a supervisor tree containing the configuration agent (IEx.Config), the broker for managing shell takeovers (IEx.Broker), and the pry infrastructure (IEx.Pry). This change decouples the shell's lifecycle and internal components—such as the evaluator, history, and autocomplete logic—from the main Elixir application, providing a more robust and modular foundation for the interactive shell.

lib/iex/lib/iex · high confidence

The internal implementation of Agent has been restructured by introducing a new Agent.Server module that explicitly uses GenServer. This change centralizes the agent's state management and message handling logic within a dedicated server process, replacing previous inline or less structured implementations. Users interacting with Agent will see no functional change, but the underlying architecture now leverages GenServer's standard lifecycle and error handling mechanisms more directly.

lib/elixir/lib/agent · high confidence

The \Logger.Backends.Console\ module is now deprecated and emits a warning at startup, directing users to migrate to the new \:console\ handler via \:default\_handler\ and \:default\_formatter\ configuration. The \lib/logger/lib/logger/backends\ directory now contains the internal implementation of this new handler-based architecture (including \Handler\, \Config\, \Internal\, \Supervisor\, and \Watcher\ modules) which replaces the old \:gen\_event\-based backend model. While the legacy \Logger.Backends.Console\ remains available for backwards compatibility, it is scheduled for removal in Elixir v1.20.

lib/logger/lib/logger/backends · high confidence

The \Supervisor.Spec\ module is now deprecated and marked as outdated. Its functions for building child specifications do not work with the module-based child specs introduced in Elixir v1.5. Users should migrate to the new child specifications outlined in the \Supervisor\ module documentation instead.

lib/elixir/lib/supervisor · high confidence

EEx now includes an \:indentation\ option (since v1.11.0) that allows users to specify an integer added to the column number after every newline, improving alignment in generated code. Additionally, syntax errors (\EEx.SyntaxError\) now include a \:column\ field and a \:snippet\ of the source code, providing more precise and helpful error messages for debugging templates.

lib/eex/lib · high confidence

The standard library now includes deprecation warnings for features scheduled for removal in Elixir v1.20, alerting users to upcoming breaking changes in the API.

lib/elixir/lib · high confidence

The Elixir build configuration has been updated to stop treating compiler warnings as fatal errors. The \Emakefile\ now includes a comprehensive list of warning flags (such as \warn\_unused\_vars\ and \warn\_export\_all\) to identify potential issues, but the \warnings\_as\_errors\ option is explicitly commented out. This change allows the build to succeed even when warnings are present, shifting the focus from strict error enforcement to warning visibility.

lib/elixir · high confidence

The GenEvent.Stream module, which allowed event managers to be consumed as enumerables, has been marked as deprecated with a clear notice that this functionality is no longer supported. The implementation remains in the codebase but is explicitly disabled for new usage, signaling that users should migrate away from streaming GenEvent notifications.

_lib/elixir/lib/gen\event · high confidence

The Logger module is now a wrapper around Erlang's native :logger functionality, providing message translation and formatting for Elixir terms. This change introduces support for all 8 syslog levels, structured logging via reports (keyword lists and maps), and integration with Erlang's logging handlers, filters, and overload protection mechanisms.

lib/logger/lib · high confidence

EEx now provides a new \EEx.Engine\ module that defines the standard callbacks (\init\, \handle\_body\, \handle\_begin\, \handle\_end\, \handle\_text\, \handle\_expr\) for building custom template engines. The existing \EEx.SmartEngine\ has been refactored to delegate to this new base, and the old \use EEx.Engine\ macro is deprecated in favor of explicit delegation. This change establishes a cleaner, more consistent API for developers creating custom EEx engines.

lib/eex/lib/eex · high confidence

The \File.Stat\ module is introduced as a dedicated struct to hold file information, providing explicit conversion functions (\to\_record\/\from\_record\) between the Elixir struct and Erlang's \:file\_info\ record, with updated typespecs allowing integer types for time fields. Concurrently, \File.Stream\ is refactored to support distributed file reading via the \node\ field, add a \:read\_offset\ option for seeking within files, and optimize the \Enumerable.count/1\ implementation for accurate line and byte counting.

lib/elixir/lib/file · high confidence

The Inspect module now uses a dedicated \Inspect.Opts\ struct to manage inspection configuration, replacing previous keyword-list handling. This struct supports options such as \:base\, \:binaries\, \:charlists\, \:custom\_options\, \:inspect\_fun\, \:limit\, \:pretty\, \:printable\_limit\, \:safe\, \:structs\, \:syntax\_colors\, and \:width\. A new \Inspect.Error\ exception has been added to wrap inspection failures, preserving the original exception, message, stacktrace, and the struct being inspected, which improves debugging when custom \Inspect\ implementations fail.

lib/elixir/lib/inspect · high confidence

Elixir now uses a dedicated \Kernel.LexicalTracker\ GenServer to track module references, aliases, imports, and requires within lexical scopes. This replaces the previous table-based approach, allowing the compiler to accurately warn about unused aliases, imports, and requires, and to distinguish between compile-time and runtime dependencies more precisely. This change improves the accuracy of compiler diagnostics and supports better handling of lexical scoping in macros and quoted code.

lib/elixir/lib/kernel · high confidence

Mix now uses a new \Mix.AppLoader\ module to read and traverse application dependencies in an optimized format, caching the results in a manifest file to speed up startup and compilation. This change improves build performance by reducing the overhead of loading application specifications and managing dependency paths during the Mix CLI execution.

lib/mix/lib/mix · high confidence

This change introduces the concrete implementations for Mix's Source Control Management (SCM) system: Mix.SCM.Git handles fetching and managing Git repositories, while Mix.SCM.Path handles local path dependencies. The Git implementation supports modern Git features such as sparse checkouts, shallow clones via the :depth option, and subdirectory extraction via the :subdir option. It also improves security by redacting credentials in URIs and validates Git options to prevent conflicts. The Path implementation ensures proper resolution of in-umbrella dependencies and local paths, raising clear errors if checkout is attempted on path dependencies.

lib/mix/lib/mix/scm · high confidence

The Task module now includes a new Task.Supervised module that handles the low-level process spawning and monitoring logic for supervised tasks, separating it from the public Task.Supervisor API. This change refactors how tasks are started and monitored, introducing a dedicated process for handling async operations and ensuring that monitor references are only set up when awaited, which reduces overhead and prevents potential race conditions during node disconnections. The Task.Supervisor module itself has been updated to delegate to this new supervised implementation, maintaining the same public interface for starting and managing tasks while improving internal stability and performance.

lib/elixir/lib/task · high confidence

The code formatting, AST normalization, and code fragment analysis capabilities are now organized into new dedicated modules: \Code.Formatter\, \Code.Normalizer\, and \Code.Fragment\. \Code.Formatter\ exposes functions like \to\_algebra/2\ and \locals\_without\_parens/0\ to handle the conversion of quoted expressions into formatted documents, while \Code.Normalizer\ provides the \normalize/2\ function to standardize AST structures before formatting. \Code.Fragment\ introduces experimental utilities for analyzing code snippets, including \cursor\_context/1\ for autocompletion support and \container\_cursor\_to\_quoted/2\ for context-aware parsing. These changes refactor the internal implementation of the \Code\ module to improve modularity and maintainability without altering the public API surface for existing users.

lib/elixir/lib/code · high confidence

A new \Stream.Reducers\ module has been added to centralize and optimize core reduction logic shared between \Enum\ and \Stream\. This change introduces efficient implementations for \zip\_with\ (handling both list and enumerable zipping) and \chunk\_every\/\chunk\_by\, allowing these operations to be performed with reduced overhead. Users benefit from improved performance and consistent behavior when using chunking and zipping functions across both modules, as the underlying logic is now unified rather than duplicated.

lib/elixir/lib/stream · high confidence

A new \Mix.Local.Installer\ module has been added to consolidate the shared functionality between archive and escript installation tasks. This change introduces a unified interface for installing artifacts from local paths, URLs, or remote dependencies (via a fetcher), supporting options such as \--force\, \--sha512\, \--sparse\, and \--organization\. Users benefit from consistent behavior and error handling across both \mix archive.install\ and \mix escript.install\ commands, with improved validation of installation sources and clearer guidance when local file paths are invalid.

lib/mix/lib/mix/local · high confidence

The String.Chars protocol has been introduced to standardize how various data types are converted to strings. This new protocol defines the \to\_string/1\ function, which is automatically imported by Kernel and invoked during string interpolation (e.g., \"foo\#{bar}"\). Implementations are provided for Atom, BitString, List, Integer, and Float, delegating to their respective module functions (such as \Atom.to\_string/1\, \List.to\_string/1\, \Integer.to\_string/1\, and \Float.to\_string/1\). This change establishes a consistent mechanism for string representation across different types, replacing ad-hoc conversion logic.

lib/elixir/lib/string · high confidence

The Logger application has been rewritten to integrate directly with Erlang's native :logger, replacing the previous gen\_event-based backend. This change introduces a new startup flow in Logger.App that configures :logger primary filters for translation and process-level logging, and registers the default handler via :logger.add\_handler. Users will see deprecation warnings if they still use the legacy :backends configuration key, which should be replaced with :default\_handler or the new LoggerBackends library. The Logger.Formatter module now provides conveniences for the new :logger formatter API, and the Logger.Translator handles the conversion of Erlang OTP reports into Elixir-compatible log messages.

lib/logger/lib/logger · high confidence

The compile-time environment representation in \Macro.Env\ has been refactored from a map to a struct. Public access is now restricted to specific fields (context, context\_modules, file, function, line, module), while internal state such as aliases, functions, macros, lexical\_tracker, and versioned\_vars is marked as private. This change enforces stricter encapsulation, requiring users to interact with the environment via the provided public API functions rather than direct map manipulation, which improves stability for tools like language servers and embedded languages.

lib/elixir/lib/macro · high confidence

The Elixir and Erlang compilers have been significantly refactored to improve compilation speed, reliability, and diagnostic accuracy. The compiler now uses a new manifest format (v37 for Elixir, v1 for Erlang) that tracks file digests, modification times, and detailed dependency graphs (compile-time, runtime, and export references) to minimize unnecessary recompilations. Key behavioral changes include parallelizing Erlang compilation, separating protocol consolidation into its own compiler module with its own manifest, and introducing a \\_\_mix\recompile\\_/0\ callback for custom recompilation logic. The compiler now returns structured diagnostics with source spans and columns, tracks external resources via \@external\_resource\, and handles stale local dependencies more robustly. Additionally, the test compiler now supports \--stale\ and \--dry-run\ modes, and protocol consolidation is optimized to only recompile changed protocols and implementations.

lib/mix/lib/mix/compilers · high confidence

The internal data structures for Mix tasks and dependency management have been migrated from Erlang records to Elixir maps. This change improves code maintainability and aligns with modern Elixir conventions, but may require updates to any custom code that directly accessed record fields via pattern matching or record selectors.

lib/mix/lib/mix/tasks · high confidence

The type checking system has been completely rewritten to use a set-theoretic approach based on Binary Decision Diagrams (BDDs) for representing types, replacing the previous implementation. This new architecture introduces a modular structure with dedicated modules for handling expressions (Expr), patterns (Pattern), function application (Apply), and type descriptors (Descr). Users benefit from more precise type inference, improved error messages, and better performance in type checking, particularly for complex map and tuple operations.

lib/elixir/lib/module/types · high confidence

The dependency resolution logic in Mix has been reorganized into distinct, private modules to improve maintainability and separation of concerns. The \Mix.Dep.Converger\ module now handles the recursive convergence of dependencies and topological sorting, including cycle detection. \Mix.Dep.Loader\ is responsible for loading dependency definitions, determining managers (Mix, Rebar, Make), and handling environment/target filtering. \Mix.Dep.Fetcher\ manages the actual fetching and updating of dependencies from their sources, while \Mix.Dep.Lock\ handles reading and writing the lockfile, including merge conflict detection. \Mix.Dep.Umbrella\ manages umbrella project child dependencies, and \Mix.Dep.ElixirSCM\ manages the Elixir/OTP version manifest. This refactoring isolates specific responsibilities, making the dependency system easier to understand and extend.

lib/mix/lib/mix/dep · high confidence

The calendar library has been refactored by splitting the monolithic implementation into separate modules for Date, Date.Range, DateTime, NaiveDateTime, Time, and the ISO calendar logic, improving code organization and maintainability. A new Duration struct has been added to represent time spans with support for year, month, week, day, hour, minute, second, and microsecond units, enabling more precise duration calculations and shifting operations across calendar types.

lib/elixir/lib/calendar · high confidence

Elixir now requires Erlang/OTP 24 or later, dropping support for previous OTP releases. This change removes compatibility code and workarounds for older Erlang versions, simplifying the codebase and allowing the use of newer Erlang features.

lib/elixir/src · high confidence

The bin scripts (elixir, iex, elixirc, mix) have been rewritten to provide a consistent, POSIX-compliant shell interface on Unix and robust support for Windows via new .bat and .ps1 wrappers. The elixir script now handles a comprehensive set of command-line options including distribution flags (--cookie, --name, --rpc-eval), release configuration (--boot, --vm-args), and logging controls (--logger-otp-reports), while iex delegates to elixir with specific IEx flags like --dbg pry and --dot-iex. The mix executable is now a lightweight Elixir script that invokes Mix.CLI.main, ensuring it works correctly when invoked from any directory or via symlinks. Windows users benefit from batch files that properly handle paths with spaces, quote arguments, and support the same core options as their Unix counterparts, with PowerShell scripts added to handle argument parsing nuances in that environment.

bin · high confidence

Add comprehensive test suite for EEx template engine; Add test fixture for verifying release environment variables; Added Dialyzer test fixtures for Elixir language constructs; Added EEx template fixtures for testing; Added Erlang EUnit test suite for Elixir's parser and tokenizer; Added ExUnit integration tests; Added comprehensive test coverage for Elixir Calendar modules; Added comprehensive test suite for IEx components; Added comprehensive test suite for the code formatter; Added comprehensive test suite for the new type checker; Added escript test fixture module; Added test coverage for Logger backends; Added test coverage for Mix core modules; Added test coverage for Registry duplicate and unique key modes; Added test fixture for compile listener notifications; Added test fixture for escript configuration; Added test fixture for handling files in umbrella apps; Added test fixture for missing mix.exs handling; Added test fixture for raw dependencies; Added test fixture for rebar config script evaluation; Added test fixture for rebar dependency resolution; Added test fixtures for Elixir config system features; Added test fixtures for Erlang compilation behavior; Added test fixtures for Mix and rebar3 integration tests; Added test fixtures for \mix test --failed\; Added test fixtures for archive installation scenarios; Added test fixtures for dependency status edge cases; Added test fixtures for dependency status scenarios; Added test fixtures for file handling and exit behavior; Added test fixtures for leex and yecc compilation; Added test fixtures for modules without a mix file; Added test fixtures for protocol consolidation scenarios; Added test fixtures for release configuration and encoding; Added test fixtures for stale test detection; Added test fixtures for the 'bar' umbrella app; Added test fixtures for umbrella project apps; Added test suite for Logger backends, formatter, translator, and utilities; Added test suite for Logger configuration and metadata APIs; Added test suite for Mix.install/2 and Mix test infrastructure; Added tests for Code.Normalizer AST formatting; Added tests for EEx tokenizer and SmartEngine; Added tests for IO.ANSI.Docs formatting; Added tests for Inspect.Algebra and Inspect.Opts; Added tests for List.Chars.to\_charlist implementations; Added tests for Macro.Env macro environment functions; Added tests for Mix sync primitives and app lifecycle tasks; Added tests for Mix.Local.Installer argument parsing; Added tests for Mix.SCM.Git validation and formatting; Added tests for Mix.Shell.IO and Mix.Shell.Quiet; Added tests for String.Chars protocol implementations; Added tests for Task.Supervisor behavior and integration; Added tests for config providers and reader; Added tests for dependency convergence, lock file formatting, and conflict detection; Added tests for protocol consolidation behavior; Expanded test coverage for Elixir core libraries; Expanded test coverage for Elixir kernel and compiler diagnostics; Initial test suite for ExUnit core components; Introduce IEx test framework and helper utilities; Tests for File.Stream distributed execution and offset support; Tests for IO.ANSI formatting, colors, and escape sequences.

The core Elixir libraries (EEx, Elixir, ExUnit, IEx, Logger, and Mix) now use the \MixProject\ module name in their \mix.exs\ files, aligning with the modern project definition style. This change also standardizes the versioning of these core applications to use \System.version()\ and explicitly sets \build\_per\_environment: false\ to ensure consistent build behavior across environments.

(dependencies) · high confidence

The Unicode character data files in lib/elixir/unicode have been updated to version 17.0.0. This includes new or refreshed data files such as IdentifierType.txt, PropList.txt, PropertyValueAliases.txt, ScriptExtensions.txt, and Scripts.txt, ensuring that Elixir's string processing, identifier validation, and normalization logic align with the latest Unicode standards.

lib/elixir/unicode · high confidence

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

• CAI 73 → 73 (+0.1)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 81 → 82 (+0.1)
• Architecture 98 → 98 (+0.6)
• Maturity 56 → 57 (+0.1)
• Readiness 83 → 83 (+0.0)
• Security 100 → 100 (+0.0)
• Event Sourcing 100 → 100 (+0.0)

• Change coupling: app.tree.ex ↔ deps.tree.ex (lib/mix/lib/mix/tasks/app.tree.ex)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — no supported dependency manifest was read
• Duplicated block (10 lines × 4) (lib/elixir/lib/module/types/helpers.ex)
• Duplicated block (11 lines × 2) (lib/mix/lib/mix/tasks/compile.ex)
• Duplicated block (12 lines × 2) (lib/elixir/lib/calendar/datetime.ex)
• Duplicated block (12 lines × 2) (lib/elixir/lib/calendar/naive_datetime.ex)
• Duplicated block (14 lines × 2) (lib/logger/lib/logger/translator.ex)
• Duplicated block (18 lines × 2) (lib/elixir/lib/calendar/datetime.ex)
• Duplicated block (19 lines × 2) (lib/elixir/lib/calendar/datetime.ex)
• Duplicated block (5 lines × 2) (lib/eex/lib/eex/compiler.ex)
• Duplicated block (5 lines × 2) (lib/elixir/lib/module/types/apply.ex)
• Duplicated block (5 lines × 2) (lib/elixir/lib/module/types/apply.ex)
• Duplicated block (5 lines × 2) (lib/elixir/lib/module/types/apply.ex)
• Duplicated block (5 lines × 2) (lib/elixir/lib/module/types/descr.ex)
• Duplicated block (5 lines × 3) (lib/elixir/lib/registry.ex)
• Duplicated block (6 lines × 2) (lib/elixir/lib/code.ex)
• Duplicated block (6 lines × 2) (lib/elixir/lib/code/formatter.ex)
• Duplicated block (6 lines × 2) (lib/elixir/lib/module/types/helpers.ex)
• Duplicated block (7 lines × 2) (lib/elixir/lib/access.ex)
• …and 77 more

• Coverage not measured — no coverage collector is wired up
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (lib/elixir/lib/enum.ex)
• Duplicated block (10 lines × 3) (lib/mix/lib/mix/tasks/clean.ex)
• Duplicated block (10 lines × 4) (lib/elixir/lib/module/types/helpers.ex)
• Duplicated block (11 lines × 2) (lib/mix/lib/mix/tasks/compile.ex)
• Duplicated block (12 lines × 11) (lib/elixir/lib/module/types/expr.ex)
• Duplicated block (12 lines × 2) (lib/elixir/lib/calendar/datetime.ex)
• Duplicated block (12 lines × 2) (lib/elixir/lib/calendar/naive_datetime.ex)
• Duplicated block (12 lines × 2) (lib/elixir/lib/version.ex)
• Duplicated block (12 lines × 3) (lib/logger/lib/logger/translator.ex)
• Duplicated block (13 lines × 2) (lib/logger/lib/logger/translator.ex)
• Duplicated block (13 lines × 2) (lib/logger/lib/logger/translator.ex)
• Duplicated block (14 lines × 2) (lib/elixir/lib/enum.ex)
• Duplicated block (14 lines × 2) (lib/mix/lib/mix/tasks/profile.cprof.ex)
• Duplicated block (18 lines × 2) (lib/elixir/lib/calendar/datetime.ex)
• Duplicated block (4–6 lines × 4) (lib/elixir/lib/module/types/helpers.ex)
• Duplicated block (5 lines × 2) (lib/eex/lib/eex/compiler.ex)
• Duplicated block (5 lines × 2) (lib/elixir/lib/hash_dict.ex)
• …and 229 more

• 175 commits — 141 feature/other, 34 fixes

• lib/elixir — 136 commits
• lib/mix — 14 commits
• lib/ex_unit — 9 commits
• .github/workflows — 8 commits
• (root) — 5 commits
• lib/iex — 2 commits
• lib/eex — 1 commit

• fix: Fix Date.to_iso8601/2 loses :format with custom calendar (#15740)
• fix: Fix DateTime convert/2 and truncate/2 ignoring custom calendar from map (#15814)
• fix: Fix IEx incomplete codepoint autocomplete crash (#15864)
• fix: Fix IEx.h/1 macro spec introspection (#15863)
• fix: Fix Kernel.SpecialForms ::/2 doc example (#15818)
• fix: Fix OptionParser wrong errors for list switch types (#15881)
• fix: Fix Task.yield_many/2 waits too long or forever when :limit exceeds task count (#15737)
• fix: Fix CALLER.macro_aliases type (#15853)
• fix: Fix File.open/2 and variants specs to accept :directory option (#15890)
• fix: Fix base64 swar singleton false positive (#15773)
• fix: Fix constant retrigger of protocol consolidations in umbrellas
• fix: Fix dark-mode logo in README (#15915)
• fix: Fix escaping of literal interpolated strings, closes #15718
• fix: Fix final sigma handling in :greek (#15791)
• fix: Fix float round/2, floor/2, ceil/2 raises wrong exception for invalid precision (#15872)
• fix: Fix functions with impossible clauses typecheck crash (#15794)
• fix: Fix inferred type of :erlang.split_binary/2 result when arg is bitstring (#15790)
• fix: Fix kernel defstruct doc example (#15867)
• fix: Fix macro dbg/3 ignores ANSI color setting (#15842)
• fix: Fix macro unescape_string/2 spec and doc (#15841)
• …and 155 more

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

elixir-lang/elixir 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.