CPANscan

The `Alien::hiredis` Perl module serves as a wrapper for the minimalistic C client library `hiredis`, which is designed for interfacing with the Redis database. This module simplifies the installation and integration of `hiredis` into Perl applications, allowing developers to leverage Redis's capabilities seamlessly. It supports various versions of `hiredis`, ensuring compatibility with older system installations while providing an easy path for users to upgrade. Notably, the recent update to version 0.014 on June 8, 2025, upgraded the shared installation to version 1.3.0 of `hiredis`, enhancing functionality and performance. This module is particularly useful for developers looking to implement Redis in their Perl projects without the complexities of managing C library dependencies directly.

Router::Ragel is a high-performance URL routing module for Perl applications that leverages the Ragel finite state machine compiler to generate efficient C code for route matching, significantly enhancing performance compared to traditional regex-based routers. It allows developers to create and manage multiple independent router instances, add both static and dynamic routes with named placeholders, and compile these routes into a highly optimized state machine for rapid path matching. This module is particularly beneficial for applications with numerous routes or high request volumes, making it an ideal choice for developers seeking speed and efficiency in their routing solutions.

EV::Pg is an asynchronous PostgreSQL client for Perl that leverages the libpq library and integrates seamlessly with the EV event loop, allowing non-blocking database operations. This module supports a wide range of features including parameterized queries, prepared statements, pipeline mode, and LISTEN/NOTIFY capabilities, making it suitable for high-performance applications that require efficient database interactions. With callbacks for handling query results and errors, EV::Pg ensures that the event loop remains responsive during database I/O operations. Notably, recent updates have enhanced its functionality with support for chunked rows and asynchronous cancel requests, further optimizing performance for large datasets and complex queries.

Mail::DMARC is a comprehensive Perl module designed for implementing Domain-based Message Authentication, Reporting, and Conformance (DMARC) protocols. It provides tools for validating incoming email messages against DMARC policies, enabling mail transfer agents (MTAs) and filtering tools like SpamAssassin to ensure that messages align with the sender's specified policies. The module supports various functionalities, including generating and sending DMARC reports, receiving and storing reports from other mail servers, and offering a user-friendly interface for viewing these reports. Recent updates in version 1.20260306 include the addition of a new script for converting SQLite to MySQL, enhancements for SSL support in MySQL, and improvements to report viewing options, making it easier for users to manage and analyze DMARC data effectively.

X11::XCB is a Perl module that provides bindings for the libxcb library, enabling low-level communication with the X11 windowing system through an object-oriented interface. Unlike higher-level graphical toolkits, X11::XCB is designed for developers who need to create simple applications, command-line utilities, or test cases that interact directly with X11 without the overhead of a full graphical framework. The module is still in early development, which means users should be cautious of potential API changes in future releases. With its straightforward syntax, X11::XCB allows for the creation and manipulation of X11 windows and other elements, making it a valuable tool for those looking to work closely with the X11 protocol in Perl.

The `Config::Model::Itself` module serves as a model editor for the `Config::Model` framework, allowing users to read, modify, and write configuration models represented as structured data. It provides a user-friendly interface, including support for a Curses UI, enabling users to interactively edit configuration models. The module facilitates the loading and saving of model files, as well as the generation of visual representations of model structures through Graphviz dot files. Recent updates in version 2.026 include enhancements to the model's support for value updates and improvements to documentation, ensuring that users have access to the latest features and clearer guidance on usage. This module is essential for developers looking to manage complex configuration data effectively within Perl applications.

App::codefork is a straightforward Perl module designed for systematically forking code by making targeted replacements in filenames and file contents across directory trees. It operates on a diff-based workflow, ensuring safety by allowing users to collect changes and preview them as a unified diff before any modifications are applied to the disk. Users can specify forking instructions through a configuration file, and the module provides methods to collect changes, generate diffs, and apply modifications when ready. With a new command-line interface introduced in version 1.000, App::codefork simplifies the process of code forking while maintaining a focus on clarity and safety.

The `Number::Phone` Perl module serves as a foundational class for managing and validating phone numbers across various countries. By utilizing country-specific subclasses, it allows developers to create and manipulate phone number objects that can automatically recognize and format numbers based on their country codes. The module provides a robust set of methods to determine the validity, type, and metadata of phone numbers, including whether they are mobile, fixed-line, or toll-free. It also integrates with Google's `libphonenumber` for additional data and validation, ensuring that users can work with international phone numbers effectively. With features like formatting, dialing instructions, and geographic information, `Number::Phone` is an essential tool for any application that requires comprehensive phone number handling.

Marky is a web application designed for managing bookmark databases, providing users with a streamlined interface for organizing and accessing their bookmarks and tutorials. Built on the Mojolicious framework and utilizing the Mojolicious::Plugin::Foil, Marky offers a modern and responsive user experience, enhanced by the inclusion of Font Awesome icons for improved visual appeal. With its straightforward functionality, Marky is ideal for anyone looking to efficiently manage their online resources.

The "String::Tagged::HTML" Perl module is a powerful subclass of "String::Tagged" designed for handling and rendering HTML content with ease. It allows users to apply various tags to strings, which can then be converted into well-structured HTML fragments using the `as_html` method. This module supports a range of HTML formatting options, including bold, italic, and links, while also enabling the creation of custom attributes for HTML elements through hash references. Additionally, it provides functionality for raw HTML content, automatic style generation, and the ability to parse existing HTML into tagged strings. With constructors for creating instances from raw HTML or standard formatting tags, "String::Tagged::HTML" simplifies the process of generating dynamic HTML content in Perl applications.

Iterator::Simple is a lightweight and efficient Perl module designed for creating and manipulating iterators. It provides a simple interface for generating iterators from various data sources, including arrays, filehandles, and code references, while supporting a range of utility functions such as mapping, filtering, and chaining. With its focus on speed, Iterator::Simple is particularly well-suited for handling large datasets without consuming excessive memory. Recent updates have improved functionality, including a fix for an issue where the `islice` function incorrectly stopped on false values instead of undef, enhancing its reliability for developers. This module is ideal for those looking to implement fast and flexible iteration in their Perl applications.

The `Genealogy::Relationship` Perl module is designed to facilitate the calculation of familial relationships between individuals represented as objects in a family tree. By utilizing methods to identify parents, unique identifiers, and gender, the module can determine the most recent common ancestor and describe the relationship between any two people, such as "grandfather" or "cousin." Recent updates in version 2.0.0 have enhanced its functionality by allowing individuals to have two parents, ensuring accurate relationship calculations through the shortest ancestral path. Additionally, the module has improved compatibility across different Perl versions and introduced new methods for retrieving relationship ancestors and abbreviating relationship descriptions. This makes it a powerful tool for genealogical research and family tree modeling.

Crypt::SecretBuffer is a Perl module designed to securely handle sensitive data by preventing accidental exposure or copying of secret values in memory. It provides a robust interface for managing secrets, allowing users to append data from console input without echoing it, and to pass secrets directly to external commands or XS functions without creating copies in Perl's memory space. The module ensures that when a SecretBuffer object is freed, the sensitive data is wiped from memory, thereby reducing the risk of leaks. Recent updates in version 0.019 have introduced constant-time operations for the `memcmp` method and the `Span->cmp` method, enhancing protection against timing attacks when comparing passwords. Additionally, the `->scan` method now includes a CONST_TIME flag for improved security, reflecting the module's ongoing commitment to safeguarding sensitive information.

Data::ZPath is a Perl module that implements the ZPath grammar, allowing users to navigate and query data structures using a flexible, UNIX-like path syntax. It supports various path segments, including wildcards and functions, and provides methods to evaluate paths against both XML documents and Perl data structures, returning primitive values or invoking callbacks for matched elements. With features like error tolerance for floating-point comparisons and support for large integers, Data::ZPath is designed for robust data manipulation. The module was initially released in March 2026, marking its entry into the Perl ecosystem.

"Dist::Build" is a modern Perl module builder designed to facilitate the creation and management of Perl distributions. It serves as an implementation of Build.PL, offering extensibility through the addition of custom scripts and a build graph that simplifies the integration of various customizations. Users can enhance its functionality by loading plugins such as Dist::Build::XS for compiling XS modules or Dist::Build::ShareDir for managing shared directories. The module provides a range of delegates for managing distribution metadata and build configurations, making it a versatile tool for developers. Notably, version 0.027 introduced compatibility improvements by removing constructs that were incompatible with Perl 5.10, ensuring broader usability across different Perl environments.

The `DateTime::TimeZone` module serves as a foundational class for managing time zone objects in Perl, enabling developers to create and manipulate time zone data effectively. It allows users to instantiate time zone objects using names from the Olson database, such as 'America/Chicago', and provides methods to retrieve offsets for specific datetimes, determine if a datetime falls within Daylight Saving Time, and check the validity of time zone names. This module is primarily designed to work in conjunction with the `DateTime` module, making it essential for applications that require accurate time zone handling. The latest version, 2.67, includes updates based on the 206a version of the Olson database, notably incorporating contemporary changes for Moldova, ensuring that users have access to the most current time zone information.

MCP::K8s is a Perl module that serves as an MCP (Model Context Protocol) server specifically designed for Kubernetes, enabling AI assistants like Claude to interact with Kubernetes clusters in a secure and RBAC-aware manner. This module dynamically discovers the permissions of the connected service account and exposes only the relevant capabilities as MCP tools, ensuring that users have access to the appropriate resources based on their permissions. It supports various authentication methods, including direct token authentication and in-cluster service account detection, and provides a set of generic tools for managing Kubernetes resources, such as listing, creating, and deleting resources. Notably, in version 0.002, MCP::K8s has transitioned to inherit from MCP::Server, allowing for lazy permission discovery, which enhances flexibility by enabling the creation of instances without an immediate cluster connection. This update also ensures that tool descriptions are dynamically updated after permission discovery, improving the overall user experience.

Travel::Status::DE::DBRIS is a Perl module that provides an unofficial interface to the bahn.de and bahnhof.de departure monitors, allowing users to retrieve real-time train departure information and related data for German railway stations. It supports both blocking and non-blocking request methods, enabling developers to easily integrate train status queries into their applications. Users can request station boards, search for nearby stations, obtain journey details, and even access carriage formation information. The module includes caching options to optimize performance and reduce the risk of hitting rate limits. The latest version, 0.25, has removed certain accessors related to train data that are no longer provided by the backend, reflecting ongoing updates to maintain compatibility with the underlying API.

The `IO::Socket::HappyEyeballs` module implements the Happy Eyeballs v2 algorithm as specified in RFC 8305, designed to enhance TCP connection establishment for dual-stack hosts that support both IPv4 and IPv6. By addressing the common issue of long timeouts when attempting to connect via IPv6, this module allows for simultaneous connection attempts to both address families, prioritizing IPv6 while also ensuring that IPv4 is quickly utilized if IPv6 fails. Users can directly create sockets with this algorithm or apply a global override to automatically enhance all outgoing TCP connections made through `IO::Socket::IP`, benefiting various libraries like `HTTP::Tiny` and `LWP::UserAgent`. The module also provides configurable options for connection attempt delays and caching of successful address families, making it a powerful tool for developers looking to improve network connectivity in their applications.

Text::HTML::Turndown is a Perl module designed to convert HTML content into Markdown format, facilitating the transformation of web content into a more readable and portable text format. By utilizing the turndown libraries, this module allows users to easily convert HTML strings into Markdown, which can be particularly useful for developers and writers looking to manage content across different platforms. The module supports UTF-8 encoded HTML and provides a function, `html2markdown`, that returns a Text::FrontMatter::YAML object, making it compatible with various Markdown flavors. While it aims for compatibility with the original JavaScript implementation, users should note that it may not pass all tests from the original library. This module is actively maintained and offers a straightforward interface for HTML to Markdown conversion.

File::StatX is a Perl module that provides an interface to the "statx" system call, enabling users to retrieve detailed file status information with enhanced capabilities compared to traditional stat functions. With this module, developers can obtain various attributes of files, such as size, timestamps, ownership, and specific filesystem features, by utilizing bitmask flags and masks to customize the information retrieved. The module supports operations on both absolute and relative paths, as well as filehandles, making it versatile for different file management tasks. By leveraging File::StatX, Perl programmers can efficiently access comprehensive file metadata, which is particularly useful for applications requiring precise file handling and analysis.

The CtrlO::PDF module is a high-level PDF creator designed to simplify the process of generating PDF documents in Perl. It provides an intuitive interface for adding various elements such as pages, headings, paragraph text, images, and tables, while managing layout and pagination automatically. With customizable options for dimensions, margins, headers, and footers, users can easily create well-structured PDFs without extensive coding. Built on the PDF::Builder library, CtrlO::PDF allows for advanced features and direct access to the underlying PDF object, making it a versatile choice for developers looking to produce feature-rich PDF documents efficiently.

The SVG Perl module is a powerful extension designed for generating Scalable Vector Graphics (SVG) documents directly from Perl code. It allows developers to create complex SVG images by constructing a nested data structure that represents the SVG DOM, enabling the addition of various graphical elements such as circles, rectangles, and paths, as well as grouping elements and applying styles. The module provides a straightforward interface for rendering SVG content into XML format, with options for standalone or inline documents, and supports features like animation and interactivity through anchors. Recent updates have improved documentation clarity and fixed issues related to comment and description rendering, ensuring that SVG elements are correctly output as XML comments. This makes the SVG module an essential tool for Perl developers looking to incorporate vector graphics into their applications.

The Env::Dot Perl module provides a flexible way to manage environment variables from a `.env` file, allowing developers to easily read and utilize these variables in their applications. With features such as the ability to specify custom file paths for dotenv files, enforce the presence of required variables, and support for different dotenv file formats, Env::Dot enhances the management of environment configurations. It also allows for hierarchical loading of environment variables from parent directories, making it suitable for projects with shared configurations. Notably, the recent version 0.020 introduced a new parameter to enforce the requirement of a `.env` file, improving error handling and usability. This module is particularly useful for developers looking to streamline their environment variable management in Perl applications.

The Perl::Critic::Policy::ControlStructures::ProhibitReturnInMappingBlock module is designed to enforce best practices in Perl programming by preventing the use of "return" statements within mapping blocks such as "map", "grep", and "sort". This policy aims to avoid unexpected behavior that arises when "return" exits the entire enclosing subroutine instead of just the block, which can lead to unintended consequences in code execution. Instead of using "return" to skip elements, developers are encouraged to use "next" for this purpose, ensuring clearer and more predictable code. This module is part of the Perl::Critic framework, which helps maintain code quality and adherence to coding standards.

MooseX is a Perl module designed to document the MooseX namespace, which is specifically intended for extensions of the Moose object system rather than general-purpose modules that utilize Moose. It facilitates the creation of Moose extensions by leveraging Moose::Exporter, allowing developers to define class or attribute traits, apply roles, or provide utility functions. This module encourages a clear naming convention, urging developers to name their modules based on functionality rather than implementation details. The latest update, version 0.002, marks the migration of the repository to the GitHub Moose organization, reflecting ongoing development and community support.

LaTeX::Replicase is a Perl module designed to facilitate the dynamic generation of TeX-LaTeX documents by acting as a minimalistic template engine. It allows users to fill templates with data by defining and substituting variable values, executing conditional actions, and capturing the output into a new document. The module supports various data structures, including scalars, arrays, and hashes, and provides a straightforward syntax for embedding tags within the TeX files. Recent updates have expanded its capabilities, including the addition of new subroutines and improved handling of input values, making it easier to create customizable and programmatically configurable documents. Notably, the latest version enhances the functionality of the %%%VAR tag, allowing for more complex data manipulations and improved debugging messages, thereby streamlining the document creation process.

Remote::Perl is a versatile Perl module designed to execute Perl scripts on remote machines via any pipe transport, such as SSH. It allows users to run both script files and inline Perl code while seamlessly relaying standard output and error in real time. The module supports on-demand fetching of missing dependencies from the local machine, making it particularly useful for environments where the remote machine has minimal setup. With the accompanying command-line tool, remperl, users can easily leverage its functionality to run scripts or commands remotely. Notably, the module requires Perl 5.36 or later on both local and remote systems, ensuring compatibility with modern Perl features.

Net::Async::NATS is an asynchronous client for the NATS messaging system, designed to work seamlessly with the IO::Async framework. This module allows developers to implement publish/subscribe messaging, request/reply patterns, and wildcard subscriptions, all while managing connections and reconnections automatically. With features like queue group subscriptions, automatic keepalive handling, and server INFO processing, it provides a robust solution for building scalable, event-driven applications. The initial release, version 0.001, introduced these capabilities, making it a valuable tool for developers looking to integrate NATS into their Perl applications.

PDL::Minuit is a Perl module that provides an interface to the Minuit library, enabling users to perform minimization routines commonly used in data fitting and optimization tasks. This module is particularly useful for those working with the Perl Data Language (PDL), as it allows for seamless integration of Minuit's powerful minimization algorithms within PDL's framework. Users can initialize a fit, define parameters with bounds, execute various Minuit commands, and retrieve results such as parameter values, uncertainties, and covariance matrices. Recent updates include enhancements to testing with Test::PDL and a fix for a previously identified issue with the parameter definition function, ensuring improved reliability and functionality for users.