CPANscan

The VAPID Perl module provides a straightforward way to implement Voluntary Application Server Identification for sending web push notifications without relying on third-party services like Firebase Cloud Messaging. With VAPID, developers can generate public and private keys, validate them, and send push notifications directly to users' browsers. The module includes functions for generating VAPID keys, building push requests, and encrypting message payloads, making it easy to integrate push notifications into web applications. Notably, version 1.05 includes enhancements to the documentation and examples, ensuring that users have clear guidance on implementing the module effectively.

PAGI (Perl Asynchronous Gateway Interface) is a Perl module designed to facilitate the development of high-concurrency web applications by providing a standard interface between asynchronous-capable Perl web servers and applications, drawing inspiration from Python's ASGI specification. This module supports modern web features such as WebSockets and HTTP/2, making it suitable for building responsive and scalable web services. Currently in active development and marked as experimental, PAGI is not yet ready for production use, and its API may undergo changes. Developers interested in contributing or following its progress can find the repository on GitHub.

The `Exception::Reporter::Summarizer::PlackRequest` module is designed to enhance the functionality of the Exception::Reporter by providing a summarization feature specifically for Plack::Request objects. By integrating this plugin, developers can obtain a concise summary of HTTP requests, which can be invaluable for debugging and error reporting in web applications built with the Plack framework. The module is currently at version 0.003, which includes a recent fix to improve its testing capabilities, ensuring better reliability and performance. Authored by Matthew Horsfall, this module is open-source and adheres to the same licensing terms as Perl itself.

JMAP::Tester::WebSocket is a Perl module designed to facilitate testing of JMAP (JSON Meta Application Protocol) servers by providing a WebSocket client interface. With this module, developers can easily establish a connection to a JMAP server and send requests for various operations, such as retrieving mailboxes or fetching message updates. By wrapping the functionality of JMAP::Tester, it allows for seamless interaction with JMAP servers over WebSockets, making it an essential tool for developers looking to ensure the reliability and performance of their JMAP implementations.

Marlin is a high-performance class builder for Perl that combines the features of Moose and Moo with a unique syntax, offering a lightweight alternative for creating object-oriented classes. It leverages Class::XSAccessor, Class::XSConstructor, and Type::Tiny::XS to provide efficient attribute handling while maintaining compatibility with older Perl versions as far back as 5.8.8. Marlin allows developers to declare class attributes easily, supports various attribute behaviors such as required fields and type constraints, and includes convenient shortcuts for common patterns. Additionally, it facilitates method delegation and offers options for strict constructors, making it a versatile choice for Perl developers looking to build robust and efficient object-oriented applications.

Minilla is a powerful CPAN module authoring tool designed to streamline the process of creating, testing, and releasing Perl distributions. With its command-line interface, users can easily generate new distributions, run tests, create tarballs, and publish their modules to CPAN with minimal configuration. Minilla emphasizes a convention-over-configuration approach, promoting best practices such as maintaining a Git repository and using a static list of prerequisites. Recent updates include a fix for multibyte characters in POD documentation, enhancing its usability for international developers. Whether you're starting a new project or migrating from other build systems, Minilla simplifies the authoring workflow, making it an essential tool for Perl developers.

Tree::RB::XS is a high-performance Perl module that implements a Red/Black Tree and an LRU Cache in C, providing efficient storage and retrieval of key-value pairs. It supports advanced features such as optimized key comparisons, O(log N) Nth-node lookups, and smart bi-directional iterators that adapt when nodes are deleted. The module allows for duplicate keys while preserving insertion order and offers case-folding for key comparisons. Additionally, it includes an LRU cache mechanism that tracks the order of node insertions, enabling efficient management of recently accessed items. Recent updates in version 0.20 include fixes for duplicate key handling in the 'put' method, the ability to alter node keys, and the introduction of a 'recent_limit' attribute that automatically prunes the oldest nodes when the collection exceeds a specified size. This makes Tree::RB::XS a versatile choice for applications requiring fast and flexible data structures.

The Complete::Util Perl module provides a set of generic routines for word completion, adhering to the Complete convention. Its primary function, `complete_array_elem`, allows users to complete a word based on an array of strings, employing various matching techniques such as substring prefix, word-mode, character-mode, and fuzzy matching, which can be customized or disabled as needed. Additional utility functions facilitate the conversion and manipulation of completion answer structures, making it easier to integrate with other completion modules. Notably, version 0.620, released on January 23, 2024, includes the unhidden `ununiquify_answer()` function, enhancing the module's functionality without introducing any functional changes.

CGI::Lingua is a versatile Perl module designed to facilitate the creation of multilingual web applications by providing robust language and country detection capabilities. With this module, developers can easily determine the preferred language of users based on their browser settings or IP address, allowing for dynamic content presentation in multiple languages. By specifying a list of supported languages in RFC-1766 format, CGI::Lingua enables applications to respond appropriately to user requests, displaying messages in the correct language or providing fallback options when necessary. Additionally, it offers features such as caching for country lookups and integration with logging systems, making it a comprehensive solution for enhancing user experience on multilingual websites.

SimpleFlow is a straightforward workflow manager and logger implemented in Perl, designed to facilitate the execution of tasks in a structured and error-checked manner, similar to tools like snakeMake or NextFlow. It allows users to define tasks with a command to execute, along with optional parameters such as input and output file checks, logging options, and error handling. Each task returns a comprehensive hash containing details like exit codes, working directories, and standard output/error, making it easy to track the execution of complex pipelines. SimpleFlow is particularly useful for automating workflows in scientific computing, where precision and clarity are paramount, ensuring that each step is validated and logged for easy debugging and analysis.

App::shcompgen is a Perl module designed to generate shell completion scripts for various command-line programs, enhancing user experience by providing intelligent auto-completion in shells like Bash, Fish, Zsh, and Tcsh. With functions to detect programs, generate completions, and manage script directories, it allows users to create tailored completion scripts that can include detailed option descriptions for improved usability. Notably, version 0.325 introduced support for Perl scripts utilizing CLI::MetaUtil::Getopt::Long, expanding the module's compatibility and functionality. This makes App::shcompgen a valuable tool for developers looking to streamline command-line interactions across different shell environments.

The Complete::Getopt::Long Perl module provides a robust solution for completing command-line arguments based on the Getopt::Long specification. With its primary function, `complete_cli_arg`, users can easily complete option names, values, and arguments, enhancing the command-line interface experience. This module operates independently of Getopt::Long's configuration, allowing for customizable behavior regarding option parsing and completion. It supports features like bundling and offers a flexible completion routine that can be tailored to specific needs, making it ideal for developers looking to implement sophisticated command-line argument handling in their applications. Additionally, it integrates seamlessly with other completion modules, providing a comprehensive toolset for command-line interface development.

The Complete::Bash Perl module provides essential routines for implementing tab completion in the bash shell, allowing developers to enhance command-line interfaces with user-friendly completion features. It facilitates the parsing of command-line input into manageable components, enabling the generation of completion suggestions based on user input. Key functions include `parse_cmdline()`, which converts raw command-line strings into structured arrays, and `format_completion()`, which formats the completion output for bash. Recent updates, such as the interpretation of a special value of -1 for `COMPLETE_BASH_FZF_ITEMS` to represent terminal height, enhance usability by allowing more flexible completion handling. This module is particularly useful for Perl scripts that require integration with bash's programmable completion capabilities, making it a valuable tool for developers looking to improve command-line interactions.

Getopt::Long::Complete is a Perl module that serves as a drop-in replacement for the traditional Getopt::Long, enhancing command-line scripts with shell tab completion capabilities. By simply replacing "use Getopt::Long" with "use Getopt::Long::Complete," developers can enable tab completion for options and arguments in their scripts, making them more user-friendly. The module supports various shells, including bash and tcsh, and allows for additional completion hints through the GetOptionsWithCompletion function, which can be customized to provide specific completions for option values and arguments. This module is particularly useful for Perl developers looking to streamline user interaction with command-line applications while maintaining compatibility with existing Getopt::Long functionality.

Getopt::Long::More is an enhanced wrapper for the popular Getopt::Long module in Perl, designed to provide additional features while maintaining compatibility with the original interface. This module allows developers to define command-line options using a more flexible and informative structure through the use of optspec objects, which enable properties such as required options, default values, and detailed descriptions for better user guidance. Notably, version 0.007 introduced an incompatible change by renaming the 'handler' property to 'destination' for consistency with Getopt::Long terminology, while still supporting the old name with a warning. This module is ideal for Perl developers looking to create robust command-line applications with improved option handling and user experience.

The `Dist::Zilla::Plugin::Test::Compile` module is a Dist::Zilla plugin designed to perform syntax checks on Perl modules and scripts within a distribution, ensuring that only core modules are utilized during testing. It generates a configurable test file (defaulting to `t/00-compile.t`) that compiles each module and script individually, which helps in identifying errors that might be missed when loading them all at once. This plugin offers various configuration options, such as skipping specific modules, faking the home directory for testing environments, and controlling warning behavior during compilation. A noteworthy recent change in version 2.059, released on December 16, 2025, enhances the plugin's functionality by allowing it to also test scripts that use the `#!(/usr/bin/)?env perl` shebang, thereby improving compatibility with different script execution environments.

The `e` Perl module is a powerful utility designed to enhance the efficiency of one-liners and script debugging by providing a suite of features that streamline various programming tasks. It allows users to add trace markers, watch references for changes, benchmark code snippets, create breakpoints, and invoke profiling tools, all while maintaining a low startup cost. Additionally, `e` facilitates data manipulation and conversion, supporting formats such as JSON, YAML, and CSV, and offers convenient functions for pretty-printing data structures and displaying them in tabular format. With capabilities for asynchronous operations and enhanced types, this module significantly accelerates development workflows, making it an invaluable tool for Perl programmers looking to optimize their coding experience.

The `Runtime::Debugger` Perl module provides an easy-to-use Read-Eval-Print Loop (REPL) that supports existing lexical variables and features intelligent tab completion, making it a valuable tool for debugging and rapid prototyping. Users can invoke the REPL in their scripts or from the command line, allowing them to interactively evaluate expressions within the current scope. Unlike other debugging tools, `Runtime::Debugger` uniquely maintains access to lexical variables, enabling developers to inspect and manipulate their code more effectively. Recent updates include the addition of rapid prototyping support and enhancements to the `p` command, which now mirrors the functionality of the new `e` command, streamlining the debugging process further.

Dist::Zilla::PluginBundle::RJBS is a comprehensive plugin bundle designed for Perl developers to streamline the process of building and managing their distributions, closely mirroring the setup used by RJBS himself. It incorporates essential plugins for version control, dependency management, and metadata configuration, while allowing for customization through additional arguments like "task" and "github_issues." This bundle simplifies the integration of testing, documentation, and versioning practices, making it an invaluable tool for developers looking to enhance their distribution workflows with minimal effort.

The Dpkg module in Perl serves as a foundational component for managing core variables related to the Debian package management system. It provides essential information about the current program, its version, and the paths to critical directories such as the configuration, database, and methods directories. This module acts as the entry point to a comprehensive hierarchy of related modules, each designed to handle various aspects of Debian package management, including architecture handling, build options, changelog parsing, dependency management, and more. By utilizing the Dpkg module, developers can efficiently access and manipulate the underlying data and functionalities necessary for working with Debian packages.

The CPAN::InGit module provides a novel approach to managing custom CPAN trees by allowing developers to pin specific versions of Perl modules for their projects within a Git repository. Instead of relying on traditional methods like Carton and cpanfile.snapshot, this module enables users to create a private CPAN mirror that serves as a version-controlled environment for their applications. By leveraging Git's capabilities, CPAN::InGit allows for easy management of module dependencies, including the ability to import modules on demand and commit changes to a designated branch. This module is particularly useful for CI/CD workflows, as it reduces the load on public CPAN by hosting modules locally. The initial release (version 0.001) marks the beginning of its functionality, with plans for future enhancements to support module curation and patch management.

The Protobuf module in Perl serves as a namespace reservation for the future development of Perl bindings for Google's Protocol Buffers, a versatile and efficient method for serializing structured data across different programming languages and platforms. Currently, the module does not implement any functionality but lays the groundwork for upcoming enhancements that will enable Perl developers to leverage Protocol Buffers in their applications.

The BACnet Perl module serves as a placeholder namespace for the BACnet Perl toolkit, providing an entry point to the actual implementation found in the BACnet::Device module. This toolkit is designed for working with the BACnet protocol, commonly used in building automation and control networks. Users are encouraged to refer directly to the BACnet::Device module for comprehensive documentation, usage examples, and API details. Recent updates include the addition of required dependencies such as ExtUtils::MakeMaker and Future::AsyncAwait, as well as various fixes to improve functionality and documentation clarity.

Cron::Toolkit is a powerful Perl module designed for parsing cron expressions with full compatibility to the Quartz Scheduler syntax, enhanced by unique features and extensive testing. It supports a comprehensive 7-field format, allowing for simultaneous specification of both day-of-month and day-of-week, wrapped day-of-week ranges, and proper handling of daylight saving time across various time zones. Users can easily generate human-readable descriptions of cron schedules, retrieve the next or previous occurrences of scheduled tasks, and debug parsed expressions with an abstract syntax tree. With over 400 rigorous tests ensuring reliability, Cron::Toolkit is an ideal choice for developers needing a robust and flexible cron parser in their applications.

App::CpanDak is a Perl module that extends the functionality of cpanm (cpanminus) by allowing users to apply patches, set environment variables, and skip tests for specific distributions. Designed as a subclass of App::cpanminus::script, it enables developers to customize the installation process of Perl modules by defining special instructions in a designated directory, which can include patches and environment configurations tailored to individual distributions. While it offers a flexible approach to managing dependencies and configurations, users should be aware that it is not compatible with cpanminus versions 1.79 or later, as those versions represent a complete rewrite of the tool.

PawsX::S3::Uploader is a Perl module designed to facilitate the uploading of data to Amazon S3 from streaming sources, making it ideal for scenarios where data cannot be fully held in memory or generated in advance. Utilizing the Paws library, it supports both small and large uploads by leveraging the "PutObject" method for objects under 5MB and multipart uploads for larger files. The module provides a straightforward interface for adding data in chunks, completing uploads, and handling errors gracefully, including automatic abortion of uploads in case of exceptions. Additionally, it allows for optional parameters such as server-side encryption and metadata, and includes a callback mechanism for progress tracking. Released in December 2025, this initial version lays the groundwork for efficient S3 interactions in Perl applications.

Catalyst::Plugin::HTML::Scrubber is a Perl module designed to enhance the security of web applications built with the Catalyst framework by sanitizing incoming parameters to prevent cross-site scripting (XSS) attacks. By integrating this plugin, developers can automatically scrub HTML tags from user inputs, while also having the flexibility to exempt specific parameters or URL paths from scrubbing. The module allows for detailed configuration options, such as controlling which HTML tags are permitted and whether to encode HTML entities. A noteworthy recent update in version 0.08 introduces the ability to exempt parameters from scrubbing based on their values, further enhancing its usability and security features. This makes Catalyst::Plugin::HTML::Scrubber an essential tool for developers looking to maintain robust security practices in their web applications.

Getopt::Guided is a Perl module that provides a robust implementation of the getopts() function, adhering to POSIX utility guidelines for command-line option parsing. It allows developers to easily define and process command-line options, storing results in a hash for convenient access. The module supports both flag options and options requiring arguments, with distinct handling for repeated flags and arguments. A notable feature introduced in version 1.1.0 is the new getopts3() function, which allows users to specify an array of argument values, enhancing flexibility by replacing the default use of @ARGV. This module is particularly useful for Perl developers looking for a compliant and user-friendly way to manage command-line options in their applications.

SPVM::Mojolicious is a real-time web framework that serves as a port of Perl's Mojolicious to the SPVM (Simple Perl Virtual Machine) environment. Currently in early development, this framework is characterized by its lack of comprehensive documentation and frequent changes to method names and functionalities, making it suitable primarily for developers who are comfortable navigating evolving codebases. It includes a variety of classes for handling HTTP requests, cookies, file management, and WebSocket communications, among others, providing a robust foundation for building real-time web applications. However, users should be aware that most tests are not yet written, indicating that the framework may still be in a state of flux.