CPANscan

Test::Spelling::Stopwords is a Perl module designed to enhance POD (Plain Old Documentation) spell-checking by integrating project-specific stopwords with the established spell-checking tool, aspell. This module simplifies the process of managing stopwords by automatically discovering and loading a .stopwords file from the project root, eliminating the need for explicit declarations in test files. It features a two-layer architecture that combines a community-maintained vocabulary from Pod::Wordlist with project-specific terms, ensuring accurate spell-checking while providing precise line-number reporting for any misspellings found. Additionally, it includes a freshness check that warns users if the .stopwords file is outdated compared to the source files, and it strips POD formatting codes to prevent false positives during checks. The initial release of this module in March 2026 introduced these capabilities, making it a valuable tool for maintaining high-quality documentation in Perl projects.

Linux::Event is a specialized event loop framework designed for Linux environments, providing a robust and efficient way to handle asynchronous events. It leverages Linux-specific features such as epoll for I/O readiness, timerfd for timers, signalfd for signal handling, eventfd for wakeups, and pidfd for process exit notifications. The module offers a stable public API, allowing developers to create and manage event loops with minimal overhead and explicit semantics. Recent updates have improved the reliability of the loop's wakeup mechanism and fixed various issues related to timer management and backend interactions, ensuring a smoother experience for users. With its focus on performance and stability, Linux::Event is an excellent choice for developers looking to implement event-driven architectures in their applications.

The Data::MessagePack Perl module provides efficient serialization and deserialization of Perl data structures using the MessagePack format, which is a binary-based alternative to JSON that offers faster performance and smaller size. This module allows developers to easily convert Perl data into a compact binary format and back, making it suitable for applications requiring high-speed data exchange, such as networking and remote procedure calls (RPC). Key features include support for streaming deserialization, options for handling integers and UTF-8 strings, and the ability to enforce canonical packing by sorting keys. Recent updates have improved performance and fixed various issues, ensuring robust handling of data structures. For more information on MessagePack, visit the official website at <http://msgpack.org/>.

Langertha is a versatile Perl module designed to provide a unified interface for interacting with various Large Language Model (LLM) APIs, including popular providers like OpenAI, Anthropic, and Ollama. It abstracts the complexities of different API implementations, allowing developers to seamlessly integrate chat, streaming, embeddings, and other functionalities across multiple LLM engines. With features such as asynchronous processing, response metadata, and a plugin system for extending capabilities, Langertha facilitates the creation of sophisticated applications that leverage AI-driven interactions. Its modular architecture supports both local and cloud-based models, making it an ideal choice for developers looking to harness the power of AI in their Perl applications.

The `Business::ISBN::Data` Perl module serves as a data pack for the `Business::ISBN` module, providing essential data derived from the ISBN Agency's `RangeMessage.xml` file. This module is typically loaded automatically by `Business::ISBN`, and it requires version 3.005 or later due to structural changes aimed at resolving issues with ISBN-13 prefixes. Users can customize their data source by setting the `ISBN_RANGE_MESSAGE` environment variable to point to an alternative `RangeMessage.xml` file, allowing for the use of the most current or historical data without needing to update the module itself. The module includes a fallback mechanism to older data if the specified file is unavailable. Recent updates have included multiple data refreshes, with the latest update occurring on February 27, 2026, ensuring that users have access to the most accurate and up-to-date ISBN information.

Amon2::Plugin::Web::CSRFDefender is a deprecated Perl module designed to provide anti-CSRF (Cross-Site Request Forgery) protection for web applications built with the Amon2 framework. It allows developers to generate and validate CSRF tokens, which are essential for securing forms against unauthorized submissions. The module includes options to disable automatic validation and HTML rewriting for performance optimization, particularly in high-traffic environments. Notably, in its latest update (version 7.04), the module has transitioned to using Crypt::SysRandom for improved security in random number generation, while also officially marking the module as deprecated, advising against its use in new projects.

The Sah::SchemaBundle::Identifier Perl module provides a collection of schemas specifically designed for validating identifiers, which are safe strings commonly used for naming variables, files, and other entities. This module includes various schemas that enforce different constraints on identifiers, such as length limits (ranging from 15 to 255 characters) and case sensitivity (supporting lowercase, uppercase, and mixed-case formats). By utilizing these schemas, developers can ensure that their identifiers conform to specific rules, enhancing code reliability and consistency. This module is part of the Sah framework, which facilitates schema validation in Perl applications.

App::cpm is a high-performance CPAN module installer designed to expedite the installation process of Perl modules by caching builds in the user's home directory. This innovative approach allows cpm to reuse prebuilt distributions, significantly reducing installation times—demonstrated to be up to three times faster than its predecessor, cpanm. The module is particularly beneficial for projects with extensive dependencies, as it minimizes the need for repeated builds. Recent updates include an internal refactor introducing App::cpm::Context and improvements in parsing options, enhancing the overall functionality and reliability of the tool. For users seeking a faster and more efficient way to manage CPAN modules, App::cpm offers a compelling solution.

Class::XSConstructor is a Perl module designed to create high-performance object constructors using XS (eXternal Subroutine) code, significantly enhancing the speed of object instantiation compared to traditional Perl methods. It supports a wide range of features, including initialization from hash references or key-value pairs, required attributes, default values, type constraints, and custom slot initializers. The module also allows for advanced functionalities such as weak references, triggers, and automatic deep data cloning. Recent updates have improved compatibility and performance, including the addition of the `clone_on_write` feature, which enables automatic deep cloning of incoming arguments. This makes Class::XSConstructor an excellent choice for developers seeking efficient and flexible object-oriented programming in Perl.

MooX::Cmd is a Perl module designed to simplify the creation of command-line interface (CLI) applications using the Moo object system. It allows developers to organize commands and subcommands in a hierarchical structure, mirroring the package structure of the application. Each command is defined as a class with an `execute` method that receives parameters for the command instance, the arguments passed to it, and the chain of commands leading to it. This structure enables the easy handling of complex command trees, where only the most specific command's `execute` method is invoked, while also providing access to attributes and options defined at higher levels in the command hierarchy. With MooX::Cmd, developers can efficiently build modular and organized CLI applications that are easy to maintain and extend.

Travel::Status::DE::VRR is an unofficial Perl module designed to interface with the VRR departure monitor, allowing users to retrieve real-time departure information for public transport in the VRR region, such as Essen. By creating a new instance of the module with specified parameters like location and stop name, users can easily access and display upcoming departures, including details such as time, platform, line, and destination. This module relies on several dependencies, including Class::Accessor and DateTime, and serves as a convenient tool for developers looking to integrate transport status functionality into their applications.

The `Config::Model::TkUI` module provides a graphical user interface (GUI) for editing configuration data using the Config::Model framework. It allows users to interactively modify configuration files, such as `/etc/X11/xorg.conf`, through a tree structure that displays configuration elements. Users can easily navigate, edit, and save changes to their configurations, with features like a search function, customizable font sizes, and a wizard for guided editing. Recent updates include the addition of a history menu and navigation buttons for improved user experience, alongside various bug fixes to enhance stability and functionality. This module is particularly useful for those who prefer a visual approach to configuration management in Perl applications.

Test::Expander is a Perl module designed to enhance testing capabilities by automating the determination of the class/module and method/subroutine being tested, thereby reducing boilerplate code and improving test readability. It integrates with Test2::V0 and offers features such as automatic creation of temporary directories and files, environment variable management through .env files, and subtest selection by name or number. Recent updates include improved support for colorization of exported variables and the ability to handle different file path delimiters across operating systems, making it a versatile tool for developers looking to streamline their testing processes.

The `JSON::Schema::Validate` Perl module is a lightweight and recursion-safe validator for JSON Schema, specifically designed to comply with the Draft 2020-12 specification. It provides a straightforward API for validating JSON data against defined schemas, supporting features such as dynamic references, annotations, and built-in format validators for common data types like dates and emails. The module allows for optional compilation of schemas for improved performance, and it can generate client-side JavaScript validators to facilitate form validation in web applications. Recent updates in version 0.8.0 have removed unnecessary dependencies and enhanced the validation of duration formats, ensuring stricter compliance with ISO 8601 standards. This makes `JSON::Schema::Validate` a robust choice for developers needing reliable JSON validation in Perl applications.

MetaCPAN::Client is a robust Perl module designed to provide a comprehensive and user-friendly interface to the MetaCPAN API, enabling developers to easily access and manipulate data related to Perl distributions, authors, modules, and more. With features that include searching for authors and distributions, retrieving recent releases, and fetching POD documentation, this module supports both simple and complex queries through a flexible hash-based search specification. Recent updates have enhanced its functionality by adding support for scrolling through more types of data and fixing issues related to fetching CVE information. This makes MetaCPAN::Client an essential tool for Perl developers looking to integrate MetaCPAN data into their applications efficiently.

DBD::Mock::Session::GenerateFixtures is a Perl module designed to facilitate the generation of mock database fixtures for testing purposes using the DBD::Mock::Session framework. It allows developers to create a mocked database handle by either providing a real DBI database handle, reading from a fixture file, or using an array of mock data. The module supports various database interactions, including transaction management with methods for beginning, committing, and rolling back transactions. Recent updates have enhanced compatibility with MySQL and Rose::DB, ensuring broader usability in different database environments. This module is particularly useful for developers looking to streamline their testing processes by simulating database interactions without the need for a live database connection.

The `Graphics::Penplotters::GcodeXY` Perl module is designed to facilitate the creation of G-code files specifically for pen plotters, allowing users to generate intricate designs directly from Perl scripts. With a range of graphics primitives such as lines, boxes, polygons, and arcs, users can easily define shapes and paths in various units (inches, millimeters, etc.). The module supports advanced features like font rendering, SVG file import, and Postscript output, making it versatile for different plotting needs. Users can customize their G-code output with options for paper size, margins, and movement commands, while also benefiting from built-in optimizations for efficient pen travel. This module is ideal for artists, engineers, and hobbyists looking to automate their pen plotting tasks with precision and flexibility.

Bundle::Maintainer::MHASCH is a Perl module that serves as a convenient collection of CPAN modules maintained by Martin Becker (MHASCH). This bundle simplifies the installation process by allowing users to install all the listed modules at once using a single command through CPAN. It includes various mathematical modules such as Date::Gregorian and several polynomial-related modules, making it particularly useful for developers who require these specific functionalities. While bundles like this one provide an easy way to gather related modules, they are less flexible than modern meta-modules, which can handle complex dependencies. Nonetheless, Bundle::Maintainer::MHASCH is an excellent resource for anyone looking to quickly set up a development environment with the essential tools maintained by Becker.

The Date::Holidays::AU Perl module provides a straightforward way to determine public holidays in Australia, utilizing the interface defined by Date::Holidays::Abstract. With its primary functions, `is_holiday` and `holidays`, users can easily check if a specific date is a holiday in a given Australian state or retrieve a list of holidays for that year. The module supports various states, including Victoria, Queensland, and New South Wales, and allows for customization through parameters specific to each state. Ideal for developers needing to incorporate holiday data into their applications, Date::Holidays::AU simplifies the process of holiday management across Australia.

App::GitKtti is a Perl module designed to enhance Git branch management by providing a suite of command-line tools that facilitate safe and efficient use of the Git flow methodology. With features such as safe branch operations, colorized output for improved readability, and support for various workflows including feature, hotfix, and release, App::GitKtti streamlines the process of managing branches. It also includes automatic branch cleanup and management, making it an essential tool for developers looking to maintain a clean and organized Git repository.

The CPANSA::DB module provides a Perl data structure containing the CPAN Security Advisory (CPANSA) reports, primarily intended for use with the CPAN::Audit module. By calling the `db` subroutine, users can access a hash reference of all CPANSA reports, which are crucial for ensuring the integrity and security of Perl modules. Each release of this module is accompanied by a GPG signature for verification, and users can also utilize GitHub Attestations to confirm the authenticity of the downloaded files. This module is available on GitHub, where it includes detailed release information and attestation capabilities, making it a vital tool for developers concerned with the security of their Perl applications.

Math::GMPz is a Perl module that provides an interface to the GNU Multiple Precision Arithmetic Library (GMP), specifically for handling large integers (mpz). This module wraps nearly all integer functions available in the GMP library, allowing users to perform arithmetic operations, comparisons, and conversions on arbitrarily large integers with ease. It supports various initialization methods for creating bignum objects, automatic memory management, and includes functions for random number generation, formatted input/output, and number-theoretic calculations. With its extensive functionality and reliance on the efficient GMP library, Math::GMPz is ideal for applications requiring high-performance arithmetic on large integers.

Net::Async::Kubernetes is an asynchronous client for interacting with Kubernetes clusters, designed to work seamlessly with the IO::Async framework. This module simplifies Kubernetes operations by providing non-blocking CRUD (Create, Read, Update, Delete) methods that return Future objects, allowing for efficient handling of asynchronous tasks. Users can easily configure the client using a kubeconfig file, in-cluster service account tokens, or explicit server and credential parameters. The module also features a robust watcher mechanism that supports auto-reconnection and event streaming, enabling real-time monitoring of Kubernetes resources with customizable callbacks for added, modified, and deleted events. Notably, version 0.004 introduced enhancements for automatic detection of kubeconfig and in-cluster service accounts, streamlining the client setup process.

Kubernetes::REST is a Perl module that serves as a REST client for interacting with the Kubernetes API, providing a simplified interface for managing Kubernetes resources. With this module, users can easily perform operations such as listing, creating, updating, patching, and deleting resources like Pods and Namespaces, all while leveraging the automatic URL building capabilities of IO::K8s resource classes. The module supports dynamic loading of resource maps from the cluster's OpenAPI specification, ensuring compatibility with various Kubernetes versions. Notably, the recent version 1.003 introduced automatic detection of in-cluster service account tokens, allowing seamless operation within Kubernetes pods without requiring a kubeconfig file. This enhancement significantly simplifies authentication for applications running in Kubernetes environments.

The `IO::K8s` Perl module provides a comprehensive interface for interacting with Kubernetes API objects, enabling users to easily create, manipulate, and serialize Kubernetes resources. With features such as loading and validating YAML manifests, programmatically creating objects, and inflating JSON data into typed Perl objects, `IO::K8s` streamlines the process of working with Kubernetes configurations. The module supports both built-in Kubernetes types and custom resource definitions (CRDs), allowing for flexible integration with various Kubernetes setups. Recent updates have improved JSON deserialization by fixing issues with recognizing sanitized field names, enhancing the module's robustness when handling complex Kubernetes structures. This makes `IO::K8s` an essential tool for developers looking to automate and manage Kubernetes resources effectively.

The TimeDate Perl module provides a comprehensive suite of date and time handling functionalities, including parsing, formatting, and timezone management. With its core components—Date::Parse for converting various date string formats into Unix timestamps, Date::Format for formatting timestamps into human-readable strings, and Date::Language for multi-language support—TimeDate is versatile for international applications. The module also includes Time::Zone for timezone offset lookups. Recent updates in version 2.34 have enhanced documentation coverage, fixed language data bugs, and introduced support for the boost C++ timestamp format, making it even more robust for developers needing precise date and time manipulation in their Perl applications.

The "Future::IO::Impl::Tickit" module provides an implementation of the Future::IO interface using the Tickit framework, enabling asynchronous I/O operations within a Tickit application. To utilize this module, developers must first create a Tickit instance and set it using the `set_tickit` method, ensuring that the Future::IO functionalities can operate correctly. Recent updates include enhancements to support the latest Future::IO features, such as the addition of the `->poll` method and improved test compatibility, while also addressing limitations regarding the POLLPRI constant, which is not currently supported by libtickit. This module is particularly useful for developers looking to integrate asynchronous I/O capabilities into their Tickit-based applications.

"Future::IO::Impl::Glib" is a Perl module that serves as an implementation of the Future::IO framework using Glib, making it an ideal choice for integrating asynchronous I/O operations within Glib or Gtk applications. By simply loading this module alongside Future::IO, developers can leverage its functionality to handle non-blocking I/O tasks seamlessly, enhancing the responsiveness of their applications without the need for additional methods. This module is particularly useful for those looking to utilize the capabilities of Glib in a straightforward manner, allowing for efficient event-driven programming in Perl.

The Net::Correios Perl module provides a convenient interface for accessing the Brazilian Postal Service's REST API, enabling developers to perform various operations such as querying postal codes (CEPs), calculating shipping prices and delivery times, and tracking packages. Designed primarily for Brazilian developers, this module requires an active commercial contract with Correios and an API key for authentication. With methods to retrieve information about shipping costs, delivery deadlines, and tracking status, Net::Correios simplifies the integration of postal services into applications, making it an essential tool for businesses and developers working with logistics in Brazil.

The `Time::ParseDate` Perl module is designed for parsing both relative and absolute date and time strings into seconds since January 1, 1970. It supports a wide variety of date formats, including common styles like "dd/mm/yyyy" and "yyyy-mm-dd," as well as relative formats such as "next Tuesday" or "3 days ago." The module offers numerous options to customize parsing behavior, such as handling time zones, requiring complete date strings, and allowing for fuzzy matching of input. A notable recent update in February 2026 added support for trailing "Z" or "z" to denote UTC in ISO 8601 timestamps, enhancing its compatibility with modern date formats. This module is particularly useful for applications that need to interpret and manipulate date and time information flexibly and accurately.