phoenixframework/phoenix

This system is the Phoenix web framework for Elixir, providing a full-stack web development environment. It includes a code generator and installer for scaffolding new applications, along with core modules for HTTP routing, controllers, and WebSockets. The framework also supplies testing utilities for channels and connections, and manages static asset compilation and compression.

24 changes.

This period focused on the development of Phoenix 1.9.0, introducing core features such as Channels, LiveView scaffolding, and a new Mix task interface. The codebase underwent significant architectural refactoring, including the router, endpoint, and code reloader, while also modernizing the default JSON library and static asset builds.

16 changes.

This period focused on significantly expanding test coverage for Phoenix's core components, including channels, connections, and the installer, while introducing new testing helpers. Concurrently, the project refactored the generator internals and introduced interactive project generation, alongside adding binary serialization support for the socket protocol.

21 changes.

This period focused on updating the Phoenix project generator to support Phoenix 1.7 and LiveView 1.2, introducing modern defaults like Tailwind CSS and dark mode support. The work also included refactoring the authentication generator, rewriting the JavaScript client, and expanding integration test coverage for code generation across multiple database adapters.

A new .formatter.exs file has been added to the project root, defining a comprehensive list of local functions that should not be surrounded by parentheses during formatting. This configuration applies to Phoenix modules including Phoenix.Channel, Phoenix.Router, Phoenix.Controller, Phoenix.Endpoint, Phoenix.Socket, Phoenix.ChannelTest, Phoenix.ConnTest, Phoenix.Live{Dashboard,View}, and Phoenix.LiveViewTest, ensuring consistent formatting for these common DSL-style function calls.

(repo-wide) · high confidence

The lib/phoenix directory now includes lib/phoenix/channel.ex, lib/phoenix/code\_reloader.ex, and lib/phoenix/debug\_page.ex. These new files introduce the core Channel API for bidirectional client-server communication, a CodeReloader module for hot code reloading in development, and a debug page implementation that supports both light and dark themes for error display.

lib/phoenix · high confidence

The Phoenix Socket serializers have been updated to support binary payloads in version 2 of the protocol. The new V2 JSON serializer encodes messages and replies as binary data when the payload is a raw binary, enabling more efficient transmission of binary data over WebSockets, while maintaining text-based JSON serialization for standard map payloads. This change allows applications to send and receive binary data directly through the socket, improving performance for binary-heavy workloads.

lib/phoenix/socket/serializers · high confidence

The installer now generates default template files for internationalization and web scaffolding. This includes new \.eex\ templates for the Gettext backend (\gettext.ex.eex\), error message catalogs (\errors.pot.eex\, \errors.po.eex\), and the main web module (\app\_name.ex.eex\) which sets up controllers, channels, and HTML helpers with Gettext integration. Additionally, it provides the Phoenix endpoint configuration (\endpoint.ex.eex\), router (\router.ex.eex\), and telemetry setup (\telemetry.ex.eex\), establishing the standard structure for a new Phoenix application.

_installer/templates/phx\_gettext, installer/templates/phx\_umbrella/apps/app\_name\_web/lib, installer/templates/phx\web · high confidence

The integration\_test directory now includes a complete local testing environment for Phoenix generated projects. Users can now run the full suite of integration tests locally using Docker Compose to spin up PostgreSQL, MySQL, and MSSQL databases, with a provided shell script (docker.sh) and test runner (test.sh) to automate the process. This setup allows developers to verify database-specific behaviors (PostgreSQL, MySQL, MSSQL, SQLite3) without relying on remote CI infrastructure.

_integration\test · high confidence

The installer now includes new template files for \core\_components.ex\ and \layouts.ex\. The core components provide reusable UI building blocks including a flash notification system, a navigation button, and a comprehensive input component. The layout templates define the application's main structure, including a header with navigation links and a theme toggle for switching between light, dark, and system-defined color schemes.

_installer/templates/phx\web/components · high confidence

The installer now includes a new \root.html.heex.eex\ template for new Phoenix projects. This template provides the base HTML structure and includes a script to manage the site's color theme. It supports a 'system' theme mode that respects the user's operating system preference, allowing the application to automatically switch between light and dark modes based on the \prefers-color-scheme\ media query.

_installer/templates/phx\web/components/layouts · high confidence

A new routing cheatsheet has been added to the documentation, providing a quick reference for common routing syntax including single routes, resources, nested routes, and scopes. The guide covers both standard route definitions and verified routes, with examples for simple and nested configurations.

guides/cheatsheets · high confidence

The template for the generated umbrella app has been expanded to include several new files: a README.md.eex with a placeholder description, a config/config.exs.eex that configures the app's namespace, Ecto repos, and mailer adapter, a formatter.exs.eex that sets up code formatting rules for Ecto and HTML templates, and a test/test\_helper.exs.eex that initializes ExUnit and conditionally sets up Ecto test helpers. These additions provide a more complete starting point for new apps, including documentation, configuration, code formatting, and test infrastructure.

_installer/templates/phx\_umbrella/apps/app\name · high confidence

The \priv/static\ directory now includes a compiled \phoenix.cjs.js\ file, providing a CommonJS-compatible build of the Phoenix.js client library. This allows the library to be used in Node.js environments or bundled with tools that expect CommonJS module exports, alongside the existing browser-focused builds.

priv/static · high confidence

Added new \Phoenix.Transports.LongPoll\ and \Phoenix.Transports.WebSocket\ modules to handle HTTP and WebSocket connections respectively. The long polling implementation supports batched messages, session management via a dedicated GenServer, and configurable timeouts. The WebSocket implementation handles connection upgrades, subprotocol negotiation, and error handling. These changes provide the underlying transport mechanisms for Phoenix channels.

lib/phoenix/transports · high confidence

A new \Phoenix.Channel.Server\ module is introduced to manage channel processes, providing explicit APIs for joining channels, retrieving socket state, and handling broadcasts. This change encapsulates the logic for channel lifecycle and message dispatch, allowing for better process supervision and testability.

lib/phoenix/channel · high confidence

The \mix phx.new\ task now supports an interactive mode that prompts users for project configuration options such as database, web interface (LiveView/HTML/API), and optional features like LiveDashboard, mailer, and i18n. This allows users to generate a Phoenix project without specifying numerous command-line flags. The implementation adds new modules (\Phx.New.Interactive\, \Phx.New.Project\, \Phx.New.Single\, \Phx.New.Web\, \Phx.New.Umbrella\, \Phx.New.Ecto\, \Phx.New.Mailer\, and \Phx.New.Generator\) to handle the interactive prompts, project state, and template generation.

_installer/lib/phx\new · high confidence

The \Phoenix.Controller.Pipeline\ module has been introduced to handle the execution of plugs within controllers. This new module defines the \\_\using\\_\ macro that sets up the controller's plug pipeline, including the \action\ function that wraps the controller's action execution in a try/catch block to handle errors and invoke fallbacks. It also provides the \plug/2\ macro to add plugs to the pipeline and the \action\_fallback/1\ macro to specify a fallback plug for error handling. The implementation includes validation for the fallback plug and ensures that function clause errors are properly converted into 400 responses.

lib/phoenix/controller · high confidence

The \lib/mix/tasks\ directory is populated with new Mix tasks to replace older, fragmented implementations. \Mix.Tasks.Compile.Phoenix\ provides a deprecation warning for the old \:phoenix\ compiler entry in \mix.exs\. \Mix.Tasks.Phx.Digest\ and \Mix.Tasks.Phx.Digest.Clean\ handle static asset compression, caching, and pruning of old files. A new \Mix.Tasks.Phx\ task serves as the main entry point, displaying help and version information. Additionally, a suite of generators is introduced: \phx.gen.auth\ for authentication, \phx.gen.cert\ for self-signed certificates, \phx.gen.channel\ for WebSockets, \phx.gen.context\ for Ecto contexts, \phx.gen.embedded\ for embedded schemas, \phx.gen.html\ for HTML controllers/views, \phx.gen.json\ for API controllers, \phx.gen.live\ for LiveViews, \phx.gen.notifier\ for email delivery, and \phx.gen.schema\ for database schemas. These tasks collectively modernize the developer experience by providing a consistent \mix phx.\*\ interface for scaffolding and build tasks.

lib/mix/tasks · high confidence

The generated umbrella project now includes a comprehensive set of configuration files (config, dev, test, prod, runtime, extra\_config) and a README template. The template supports LiveView 1.2, with specific configuration for \phoenix\_live\_view\ (e.g., \root\_tag\_attribute\, \debug\_heex\_annotations\). The \mix.exs\ includes \Phoenix.CodeReloader\ listener and \phoenix\_live\_view\ as a dependency for formatting \.heex\ files. The \runtime.exs\ configures live reload patterns for development and DNS cluster queries for production. The \formatter.exs\ includes the \Phoenix.LiveView.HTMLFormatter\ plugin. The \gitignore\ includes standard Elixir/Phoenix artifacts and SQLite3 database files if applicable.

_installer/templates/phx\umbrella · high confidence

The installer now provides dedicated generators for creating Ecto and Web applications within an umbrella project. Running \mix phx.new.ecto\ scaffolds a new Ecto application without web integration, while \mix phx.new.web\ creates a web application without database integration. Both tasks enforce that they are run inside an umbrella's \apps/\ directory, allowing developers to incrementally build out the components of a larger Phoenix umbrella project.

installer/lib/mix · high confidence

Phoenix now allows users to configure which static file compressors are used during the digester process. By default, Gzip compression is applied, but the system is now extensible: users can define custom compressor modules (such as a Brotli implementation) and register them in the \static\_compressors\ configuration list. This enables support for additional compression algorithms beyond the built-in Gzip.

lib/phoenix/digester · high confidence

The installer now generates new \ErrorHTML\ and \ErrorJSON\ controller templates that provide default error page rendering. The \ErrorHTML\ module renders plain text status messages, while \ErrorJSON\ returns a JSON object with an \errors\ map containing the status message. Additionally, new \PageController\ and \PageHTML\ templates are added to serve the application's home page, including a detailed setup guide for Elixir installation on Windows and Unix-like systems.

_installer/templates/phx\web/controllers · high confidence

The internal implementation of the Phoenix router has been restructured into separate, dedicated modules: \Phoenix.Router.ConsoleFormatter\ for formatting route output, \Phoenix.Router.Helpers\ for generating route helper functions, \Phoenix.Router.Resource\ for resource route definitions, \Phoenix.Router.Route\ for route structs and expression building, and \Phoenix.Router.Scope\ for managing router scopes. This refactoring replaces the previous monolithic \Phoenix.Router\ and \Phoenix.Router.Mapper\ modules, which have been removed. The change improves code organization and maintainability of the routing system.

lib/phoenix/router · high confidence

The code reloader's internal architecture has been refactored to use dedicated GenServer processes for managing state and coordinating compilation. A new Mix listener (MixListener) is introduced to track module changes and handle purging, while a Proxy GenServer captures diagnostic output. The main server (Server) now coordinates these components, ensuring that module purging and compilation are handled through these new processes rather than the previous monolithic approach.

_lib/phoenix/code\reloader · high confidence

The internal implementation of the Phoenix generators has been restructured by moving logic from the monolithic Mix.Phoenix module into three new, dedicated modules: Mix.Phoenix.Context, Mix.Phoenix.Schema, and Mix.Phoenix.Scope. This refactoring organizes the codebase to better support the new generator options and features, such as scoped routes and context-specific configurations, by separating the concerns of context generation, schema definition, and route scoping.

lib/mix/phoenix · high confidence

The JavaScript client library has been completely rewritten, introducing a new \Ajax\ module that supports \fetch()\ for modern browsers while maintaining \XMLHttpRequest\ and \XDomainRequest\ for legacy IE compatibility. The \LongPoll\ transport now supports batching messages to resolve race conditions and includes \fetch()\ as a fallback when \XMLHttpRequest\ is unavailable. Additionally, the \Presence\ module has been updated to use null-prototype objects to prevent key collisions with the object prototype chain, and the \Channel\ class now buffers pushes sent before joining to ensure reliable delivery.

assets/js · high confidence

A new configuration file for the integration test environment has been added to ensure consistent testing conditions. The setup specifies the JSON library as Jason, disables the Swoosh API client, sets the Tailwind CSS version to 4.1.12, and enables expensive runtime checks for Phoenix Live View.

_integration\test/config · high confidence

The application's configuration now explicitly sets up esbuild to generate three JavaScript output formats—ESM, CommonJS, and IIFE—during development. This change, combined with the switch to the \Config\ macro (replacing \Mix.Config\), ensures that the built assets are correctly formatted for modern module systems while maintaining compatibility with older bundlers and global script tags. Users will see the application compile JavaScript assets into \../priv/static/\ with the specified formats, improving module interoperability and build performance in the dev environment.

config · high confidence

Phoenix now defaults to using the Jason library for JSON encoding and decoding, replacing the previous default of Poison. The \Phoenix.json\_library/0\ function is now public and returns the configured JSON library, defaulting to \Jason\. Users who have not explicitly configured a JSON library will see improved performance and compatibility with modern Elixir projects. If a custom JSON library is configured but not available, a warning is emitted to guide users to add the dependency.

lib · high confidence

All template files in the installer (PhxEcto, PhxMailer, and PhxTest) have been renamed to use the .eex extension. This change ensures that the template files are correctly identified as EEx templates by the build system, allowing the template engine to process them during the application generation process.

_installer/templates/phx\_ecto, installer/templates/phx\_mailer, installer/templates/phx\test · high confidence

The installer is now provided as a Hex archive that can be installed via \mix archive.install hex phx\_new\. The \installer\ directory now contains a \README.md\ with updated installation and build instructions, a \.gitignore\ file, and a \recreate\_default\_css.exs\ script that generates default CSS for the Phoenix application. This change simplifies the installation process and ensures that users can build and install the installer locally.

installer · medium confidence

The \Phoenix.Socket\ module now relies on a clearly defined \Phoenix.Socket.Transport\ behaviour, allowing custom socket implementations to integrate with existing transports. New structs (\Phoenix.Socket.Message\, \Phoenix.Socket.Reply\, \Phoenix.Socket.Broadcast\) standardize the format of messages sent between the client and server, replacing the previous ad-hoc map structures. Additionally, a \Phoenix.Socket.Serializer\ behaviour is introduced to allow custom message encoding/decoding, and a \PoolSupervisor\ is added to manage socket process pools.

lib/phoenix/socket · high confidence

The Phoenix endpoint implementation has been restructured into separate modules for better organization and maintainability. A new \Phoenix.Endpoint.Supervisor\ module now handles the endpoint supervision tree, including configuration, warmup, PubSub, sockets, servers, and watchers. Error rendering logic has been extracted into \Phoenix.Endpoint.RenderErrors\. Additionally, \Phoenix.Endpoint.Watcher\ and \Phoenix.Endpoint.SyncCodeReloadPlug\ are now distinct modules. The \Phoenix.Endpoint.Cowboy2Adapter\ is also a new dedicated module. These changes centralize endpoint configuration, improve code reloading reliability, and provide clearer separation of concerns within the endpoint lifecycle.

lib/phoenix/endpoint · high confidence

The \phx.gen.auth\ generator's internal logic has been reorganized into three new modules: \HashingLibrary\ (handling password hashing configurations for bcrypt, pbkdf2, and argon2), \Injector\ (managing the injection of dependencies, config, router plugs, and UI menus), and \Migration\ (generating database migrations with adapter-specific column definitions). This refactoring improves maintainability and clarity of the codebase without changing the generator's external behavior.

lib/mix/tasks/phx.gen.auth · high confidence

The lib/mix/phoenix.ex file was created, introducing new utility functions for Phoenix generators. Specifically, it adds \eval\_from\ and \copy\_from\ for handling EEx template evaluation and file copying, as well as \inflect\ for name inflection, \check\_module\_name\_availability!\ for module name validation, and \base\/\context\_base\ for retrieving namespace configurations. These changes support the generator improvements and context path handling seen in the commit history.

lib/mix · medium confidence

The generated application now includes a new \app.css.eex\ template that configures Tailwind CSS with the daisyUI plugin and provides pre-built light and dark themes. The \app.js.eex\ template has been updated to support LiveView 1.2, including proper imports for \phoenix\_live\_view\ and \phoenix\_html\, along with live-reload and debugging helpers. Additionally, a \heroicons.js.eex\ template is now provided to automatically generate Tailwind CSS classes for Heroicons, and a \tsconfig.json.eex\ is included to support TypeScript autocompletion for Phoenix and LiveView JavaScript APIs.

_installer/templates/phx\assets · high confidence

The \phx.gen.auth\ templates have been updated to include new LiveViews for login and email confirmation, alongside updated context and test templates. The login flow now supports both magic links and password-based authentication, with the login page displaying a message about re-authenticating for sensitive actions. The confirmation flow handles both unconfirmed and confirmed users, redirecting to the login page if the user is already confirmed. The auth module now includes a \disconnect\_sessions\ function to broadcast disconnect events to existing LiveViews. Test templates have been updated to cover the new login and confirmation LiveViews, as well as the updated auth module functions.

priv/templates · high confidence

The installer templates for static assets have been updated to include a new default CSS file (default.css) that provides basic styling using Tailwind CSS and daisyUI, ensuring the default generated application has a styled appearance even without Tailwind. Additionally, the template now includes a default robots.txt file to control search engine indexing, and the app.js template has been updated to include a script for handling flash message dismissal.

_installer/templates/phx\static · medium confidence

The configuration templates for new Phoenix projects have been updated to align with Phoenix 1.7+ and LiveView 1.2 standards. For single-app projects, the \config/runtime.exs\ now includes a \live\_reload\ configuration block that watches for changes in static assets, translations, and web layer files. The \config/dev.exs\ and \config/test.exs\ templates now configure \phoenix\_live\_view\ with \debug\_heex\_annotations\, \debug\_attributes\, and \enable\_expensive\_runtime\_checks\ set to \true\ to aid in development and testing. Additionally, the \config/prod.exs\ templates now explicitly configure \force\_ssl\ with HSTS headers and set the logger level to \:info\ in production. For umbrella apps, the web app's configuration templates have been updated to reflect these same behavioral changes, ensuring consistent behavior across project types.

_installer/templates/phx\_single/config, installer/templates/phx\_umbrella/apps/app\_name\web/config · medium confidence

The project templates now require Elixir 1.17 and specify Phoenix LiveView 1.2.0 as a dependency, ensuring compatibility with the latest LiveView API. Additionally, the generated mix configuration explicitly requires Tailwind CSS version 0.5 or higher to support ColocatedCSS, and the formatter configuration has been updated to include the Phoenix.LiveView.HTMLFormatter plugin for HTML template formatting.

_installer/templates/phx\_single, installer/templates/phx\_umbrella/apps/app\_name\web · medium confidence

Add comprehensive test suites for Phoenix.ConnTest and Phoenix.ChannelTest; Add layout template fixtures for testing; Add tests for Mix.Phoenix schema generation; Added SSL certificate and private key fixtures for testing; Added comprehensive router tests; Added comprehensive test coverage for Phoenix.js client components; Added comprehensive test suite for the Phoenix installer; Added comprehensive tests for Phoenix.Endpoint behavior and configuration; Added integration test support utilities; Added integration tests for code generation across multiple database adapters; Added template fixture files for template engine testing; Added template fixtures for user templates; Added test fixtures for Phoenix.View and layout rendering; Added test fixtures for asset digesting and cache manifest generation; Added test helper templates for generated applications; Added test support module for integration tests; Added tests for Phoenix Socket message handling, serialization, and transport; Added tests for channel, code reloading, config, debug, digester, logger, naming, param, presence, token, and verified routes; Added tests for the phx.gen.auth generator's dependency injection logic; Added unit tests for Phoenix generator tasks; Expanded integration tests for Phoenix endpoints, long-polling, and WebSockets; New test helpers for Phoenix channels and connections; Updated test suite configuration and helpers.

Updated the project's dependencies to align with Phoenix 1.9.0-dev. This includes upgrading to Elixir 1.15+ for new apps, updating the \phx\_new\ installer to require Elixir 1.17+, and refreshing the integration test dependencies to include \phoenix\_live\_view\ 1.2.0, \phoenix\_html\ 4.1, and various database and utility libraries. The root \package.json\ and \package-lock.json\ have been added to manage JavaScript dependencies, while the main \mix.exs\ has been modernized to use \Mix.Project\ and explicitly list all framework dependencies.

(dependencies) · high confidence

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

• CAI 52 → 52 (-0.4)
• Rubric changed (rubric-2026.08.18 → rubric-2026.08.19) — scores are not directly comparable.

• Code Health 55 → 60 (+5.3)
• Architecture 97 → 97 (+0.1)
• Maturity 61 → 61 (+0.2)
• Readiness 37 → 37 (+0.0)
• Security 78 → 70 (-8.0)

• Dimension evaluation failed
• Duplicated block (14 lines × 2) (lib/mix/tasks/phx.gen.auth.ex)
• Duplicated block (17 lines × 2) (lib/phoenix/router/helpers.ex)
• Duplicated block (19 lines × 2) (lib/mix/tasks/phx.gen.auth.ex)
• Duplicated block (24 lines × 2) (lib/mix/tasks/phx.gen.html.ex)
• Duplicated block (9 lines × 2) (lib/mix/tasks/phx.gen.html.ex)
• Off-boarding risk: anonymized user #1

• Duplicated block (13 lines × 2) (lib/mix/tasks/phx.gen.auth.ex)
• Duplicated block (17 lines × 2) (lib/phoenix/router/helpers.ex)
• Duplicated block (18 lines × 2) (lib/mix/tasks/phx.gen.auth.ex)
• Duplicated block (22 lines × 2) (lib/mix/tasks/phx.gen.html.ex)
• Duplicated block (8 lines × 2) (lib/mix/tasks/phx.gen.html.ex)
• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (package-lock.json)
• High CVE: [GHSA redacted] (package-lock.json)
• High vulnerability: [GHSA redacted] (package-lock.json)
• Medium CVE: EEF-[CVE redacted] (mix.lock)
• Medium CVE: EEF-[CVE redacted] (mix.lock)
• Medium CVE: EEF-[CVE redacted] (mix.lock)
• Medium CVE: EEF-[CVE redacted] (mix.lock)
• Medium CVE: EEF-[CVE redacted] (mix.lock)
• …and 5 more

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

phoenixframework/phoenix 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.