CPANscan

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 control tags within TeX files. Recent updates have expanded its capabilities, allowing for more complex data structures and improved error handling, making it easier to create customizable and programmatically configurable documents. With features like output to console and enhanced debugging options, LaTeX::Replicase is well-suited for generating consistent and tailored TeX documents efficiently.

The `DateTime::Format::Natural` Perl module is designed to parse informal natural language date and time strings, allowing users to convert human-readable date expressions into `DateTime` objects. It supports a wide range of input formats, such as "tomorrow morning," "next Tuesday at 2 PM," and "10 weeks ago," making it versatile for various applications. The module also provides functionality to extract date/time substrings from ordinary text, enabling further manipulation or parsing. Recent updates include improved support for fractional seconds in ISO 8601 strings and optional time zone information, enhancing its usability for developers working with diverse date formats. This module is particularly useful for applications that require user-friendly date input, such as scheduling or event management systems.

Net::BitTorrent is a modern, high-performance BitTorrent client library for Perl, designed to support both BitTorrent v1 and v2 protocols. It offers a loop-agnostic architecture, allowing integration with various event loops or synchronous environments, and includes built-in security features such as DHT security and protocol encryption. The library simplifies torrent management by providing a unified method to add torrents via magnet links, .torrent files, or infohashes, and it supports advanced functionalities like decentralized discovery, peer management, and file storage. Notably, the recent version 2.0.0 marks a complete rewrite of the library, enhancing its performance and usability while adhering to modern Perl standards.

App::pod2gfm is a Perl module designed to facilitate the conversion of POD (Plain Old Documentation) files into GitHub Flavored Markdown (GFM) format. It serves as the core implementation for the pod2gfm wrapper script, managing the processing of command-line options and filehandles before delegating the actual conversion task to the Pod::Markdown::Githubert module. With a focus on simplicity, App::pod2gfm defaults to UTF-8 encoding, supports writing to multiple output files without overwriting existing ones, and provides methods for initializing and executing the conversion process. This module is particularly useful for developers looking to enhance their documentation for GitHub repositories while ensuring ease of use and error handling.

The Perl module `Alien::RtMidi` serves as a wrapper for the RtMidi library, enabling its installation and use within other Perl distributions on CPAN. It first attempts to locate an existing installation of RtMidi on the user's system; if none is found, it automatically downloads and installs the source code in a private location for future use. This module is particularly useful for developers looking to integrate MIDI functionality into their Perl applications using the FFI::Platypus interface. The latest version, 0.12, includes minor enhancements for macOS support and updates to error message handling, reflecting ongoing improvements to ensure compatibility across different platforms.

Flat::Schema is a Perl module designed to create deterministic schema contracts for flat files, particularly useful in ETL (Extract, Transform, Load) processes where data formats can change unexpectedly. By generating a stable schema from observed data profiles, it helps users explicitly define what tabular data should look like, capturing any ambiguities as issues for future validation. The module allows for user-defined overrides to accommodate changes in data structure, such as altering data types or marking fields as nullable, while ensuring that the schema remains consistent and reproducible through deterministic serialization to JSON and YAML formats. This functionality is crucial for maintaining data integrity and facilitating audits or incident reviews. The initial public release of Flat::Schema includes foundational features like type and nullability inference, making it a valuable tool for data professionals.

MIDI::Stream is a Perl module designed for encoding and decoding MIDI bytestreams in real-time. It provides stateful classes that facilitate the handling of MIDI data for a single port, device, or bytestream, ensuring that multiple streams are not processed simultaneously to avoid issues like message collisions or inaccurate tempo measurements. For users looking to convert MIDI bytestreams into actionable events, the module offers MIDI::Stream::Decoder, while MIDI::Stream::Encoder is available for transforming performance and system events into MIDI bytes suitable for hardware and software integration. Released in February 2026, this initial version lays the groundwork for efficient MIDI data manipulation in Perl applications.

Geo::What3Words is a Perl module that facilitates the conversion between WGS84 coordinates and three-word addresses using the what3words.com HTTPS API. With this module, users can easily transform geographic coordinates into unique three-word addresses, which represent specific 3m x 3m squares across the globe, and vice versa. The module supports multiple languages and provides various methods for both forward and reverse lookups, as well as validation of word formats. Notably, version 3.0.0 marked a significant update by adopting the latest version of the what3words API, ensuring enhanced functionality and support. This module is ideal for developers looking to integrate precise location services into their applications.

The `Data::Domain` Perl module provides a robust framework for describing and validating complex data structures, allowing developers to define constraints on scalar values, arrays, and hashes with ease. It supports a variety of built-in domain types such as integers, strings, dates, and custom structures, enabling detailed validation rules including minimum and maximum values, regular expressions, and contextual dependencies. The module's `inspect` method checks if data conforms to the defined domain, returning structured error messages for any mismatches, while the `validate` method can produce a validated copy of the data with default values filled in. Recent updates in version 1.16 introduced a new domain type, `Struict`, and the `-if_absent` parameter, enhancing the module's expressiveness and usability for developers working with nested data structures.

The `WWW::Bund` Perl module serves as a client for accessing various APIs provided by the German Federal Government, available at bund.dev. With support for 16 APIs and 78 endpoints, it facilitates the retrieval of data related to traffic, weather, news, water levels, and parliamentary information. The module offers a flexible interface for making API calls, including a generic method and type-safe adapters for commonly used APIs like Autobahn and NINA. It features built-in caching for responses, configurable time-to-live settings, and enforces rate limits per API to ensure efficient usage. Additionally, users can discover available APIs, search for specific services, and obtain detailed metadata about each API, making `WWW::Bund` a comprehensive tool for developers working with German governmental data.

Net::Async::Kubernetes is an asynchronous client for interacting with Kubernetes clusters using the IO::Async framework in Perl. Designed for non-blocking operations, it allows developers to perform CRUD (Create, Read, Update, Delete) actions on Kubernetes resources such as Pods and Deployments through Future objects, enabling efficient handling of asynchronous tasks. The module supports automatic loading of configuration from kubeconfig files, making it easy to connect to Kubernetes clusters with minimal setup. Additionally, it features a watcher mechanism that provides real-time updates on resource changes, complete with customizable callbacks for added, modified, or deleted resources. This module is ideal for developers looking to integrate Kubernetes management into their Perl applications while leveraging the power of asynchronous programming.

Kubernetes::REST is a Perl module designed to facilitate interaction with the Kubernetes API through a RESTful interface. It allows developers to easily connect to a Kubernetes server by configuring necessary credentials and server details, including SSL options for secure communication. The module provides access to various API groups, enabling users to perform operations such as listing pods across all namespaces or managing resources within specific namespaces. As of the latest update, version 0.02, the module has improved functionality by fixing issues related to API calls that require a body parameter, enhancing its reliability for developers working with Kubernetes.

*Data::ObjectDriver* is a powerful object-relational mapper (ORM) for Perl that simplifies the interaction between object-oriented code and relational databases. It allows developers to define classes that represent database tables, complete with properties and methods for data manipulation, while abstracting the underlying database interactions. With built-in support for caching and data partitioning, *Data::ObjectDriver* enables efficient data retrieval and storage across multiple databases without requiring changes to application logic. Recent updates, such as the fix for bulk inserts involving binary values in version 0.27, enhance its functionality, making it a robust choice for developers looking to streamline database operations in their Perl applications.

The `GitHub::Crud` Perl module provides a comprehensive interface for performing Create, Read, Update, and Delete (CRUD) operations on GitHub repositories, including managing files, commits, issues, and web hooks. It allows users to easily upload files, commit changes, read file contents, and manage repository issues directly from Perl scripts. With features such as personal access token management, the ability to list repository contents, and the capability to create web hooks, this module simplifies interactions with the GitHub API, making it an essential tool for developers looking to automate their GitHub workflows.

The `IO::K8s` Perl module provides a robust framework for interacting with Kubernetes API objects, enabling developers to easily create, manipulate, and serialize Kubernetes resources in a type-safe manner. With features such as loading and validating YAML manifests, programmatically creating Kubernetes objects, and inflating JSON data into typed Perl objects, `IO::K8s` streamlines the management of Kubernetes resources. The module supports both built-in Kubernetes types and custom resource definitions (CRDs), allowing for flexible integration with various Kubernetes setups. Notably, the recent version 1.000 introduced a major refactor from Moose to Moo for improved performance and lighter dependencies, along with updates to align with the Kubernetes v1.31 API, enhancing its overall functionality and usability.

The Term::ANSIEncode Perl module provides a markup language for generating ANSI text, enabling developers to create colorful and formatted terminal output. It requires a UTF-8 compatible terminal to display special characters and supports a variety of text attributes such as bold, underline, and color changes for both foreground and background. Users can easily instantiate the module and utilize a range of tokens to manipulate cursor position, clear the screen, and create frames around text. Recent updates have significantly improved token handling and documentation, with version 1.88 streamlining the installation process by removing unnecessary prerequisites, enhancing usability for developers looking to enrich their terminal applications with ANSI formatting.

Crypt::NaCl::Sodium is a Perl module that provides a modern and user-friendly interface to the libsodium library, enabling developers to implement a wide range of cryptographic operations including encryption, decryption, digital signatures, password hashing, and more. With support for both secret-key and public-key cryptography, it offers functionalities such as authenticated encryption (XSalsa20/Poly1305, ChaCha20/Poly1305), message authentication (HMAC variants), and various hashing algorithms (Blake2b, SHA-2). The module emphasizes security and performance, making it suitable for building higher-level cryptographic tools while ensuring that operations are faster than many traditional implementations. Additionally, it includes utility functions for data manipulation and secure storage, making it a comprehensive solution for cryptographic needs in Perl applications.

Aion is a sophisticated object-oriented programming framework for Perl 5, designed to enhance class creation with features such as aspects and roles, similar to other frameworks like Moose and Moo, but with notable improvements. It allows developers to define class properties (features) and their behaviors (aspects) using a simple syntax, enabling advanced functionalities like dependency injection, method signature checking, and type coercion. Recent updates in version 1.6 include a bug fix related to the `isa` aspect and string handling, further refining its capabilities. Aion is ideal for developers seeking a modern and flexible approach to object-oriented programming in Perl.

Log::Dispatch is a versatile Perl module designed for logging messages to multiple outputs through a unified interface. It allows developers to create a logging object and add various output handlers, such as file and screen loggers, enabling messages to be dispatched to different destinations with minimal code. The module supports various log levels, from debug to emergency, and provides methods for logging messages, including the ability to use callbacks for message modification. Recent updates in version 2.71 have clarified the documentation for the Screen output, addressing previous inconsistencies, which enhances usability for developers. This module is particularly useful for applications that require flexible logging mechanisms, allowing for easy integration of different logging strategies.

IPC::LockTicket is a Perl module that provides a FIFO token locking mechanism for inter-process communication (IPC), allowing multiple processes to safely access shared resources without conflicts. It utilizes the Storable library to facilitate the transfer of custom data between processes, ensuring that data is only updated when explicitly requested. The module supports creating lock files with specified permissions and offers methods for acquiring and releasing locks, as well as for setting and retrieving custom data references. By managing locks effectively, IPC::LockTicket helps prevent data corruption and ensures that processes can operate in a coordinated manner, making it an essential tool for applications that require synchronized access to shared resources.

Plack::Middleware::DirIndex::Htaccess is a Perl module designed to replicate the Apache web server's DirectoryIndex functionality within a Plack environment, allowing for seamless handling of directory URLs. By reading the DirectoryIndex directives from existing .htaccess files, this middleware ensures that requests for directories automatically serve the appropriate default HTML files, such as "index.html" or any specified alternative. If no DirectoryIndex directive is found, it defaults to serving "index.html" if it exists, thereby enhancing the user experience by providing expected content without additional configuration. This module is particularly useful for developers looking to maintain consistency between local development and production environments.

Plack::Middleware::DirListing is a Perl module designed to enhance web applications by providing a clean HTML directory listing for specified directories. It functions similarly to Plack::App::Directory but is specifically tailored to serve directory listings only, without attempting to serve individual files. This middleware aims to deliver a user interface that resembles a polished version of the Apache web server's output, making it visually appealing and user-friendly. By default, it uses the current directory as the document root, but this can be configured as needed. Notably, the module is in its initial version as of February 2026, marking its debut in the Perl ecosystem.

Net::Async::Hetzner is a Perl module that provides asynchronous clients for interacting with Hetzner's APIs, leveraging the IO::Async framework for non-blocking operations. It includes two primary clients: Net::Async::Hetzner::Cloud for managing cloud resources such as servers and volumes, and Net::Async::Hetzner::Robot for handling dedicated server management. All HTTP methods return Future objects, allowing for efficient asynchronous programming. The module delegates request building, authentication, and response parsing to WWW::Hetzner, ensuring consistent JSON handling and error messaging. The initial release (version 0.003) introduced these features, including basic authentication support for the Robot API, making it a robust choice for developers looking to integrate Hetzner services into their applications.

The `WWW::Hetzner` Perl module serves as a comprehensive client for interacting with Hetzner's various APIs, including the Cloud API for managing cloud servers and DNS, and the Robot API for handling dedicated servers. With this module, developers can easily create, list, and manage cloud resources such as servers, SSH keys, volumes, networks, and firewalls, as well as perform operations on dedicated servers like resets and IP management. The module provides a unified interface, making it straightforward to integrate Hetzner's services into Perl applications, while also offering command-line tools for quick access to functionalities. Whether you're deploying cloud infrastructure or managing dedicated servers, `WWW::Hetzner` simplifies the process with its well-structured API classes and entity models.

Net::DAVTalk is a Perl module designed to facilitate communication with DAV (Distributed Authoring and Versioning) servers, serving as a foundational service for modules like Net::CalDAVTalk and Net::CardDAVTalk. It abstracts the complexities of connecting to a DAV server and parsing XML responses, allowing users to perform various operations such as creating calendars, deleting resources, and retrieving properties with ease. The module supports both basic and OAuth2 authentication, customizable headers, and provides methods for handling paths and generating UUIDs. A noteworthy recent addition in version 0.24 is the introduction of the "SafeRequest" API, which captures errors without throwing exceptions, enhancing error handling during DAV requests. This makes Net::DAVTalk a robust choice for developers needing to interact with calendar and contact data on DAV-compliant servers.

"Alien::libtickit" is a Perl module that serves as a wrapper for the C library libtickit, facilitating its integration into CPAN and other Perl build systems. It simplifies access to the library's configuration, leveraging pkg-config if the library is already installed, or it can install a bundled version of libtickit (specifically version 0.4.6) into the appropriate Perl architecture-specific directory if necessary. The module mimics the behavior of ExtUtils::PkgConfig, allowing users to easily retrieve compiler flags and library paths, as well as check for version compatibility, making it an essential tool for developers working with libtickit in Perl applications.

Search::Fzf is a Perl module that integrates the powerful fuzzy search capabilities of the popular command-line tool fzf into Perl applications. By utilizing the fzf function, developers can implement fuzzy querying on arrays of strings or file handles, allowing for efficient and user-friendly search experiences. The module offers extensive configuration options, including customizable prompts, selection markers, and various fuzzy matching algorithms, enabling fine-tuning to meet specific needs. Recent updates have included code cleanup and resolution of module conflicts, enhancing the module's stability and performance. With its rich feature set and ease of use, Search::Fzf is an excellent choice for Perl developers looking to add advanced search functionality to their applications.

The "Future::IO::Impl::Tickit" module provides a specialized implementation of the "Future::IO" interface that integrates with the Tickit event system, allowing for asynchronous I/O operations within a Tickit application. To utilize this module, developers must first create a Tickit instance and set it as the top-level object using the "set_tickit" method, enabling the event-driven capabilities of Future::IO. This module is particularly useful for applications that require non-blocking I/O while leveraging the features of the Tickit framework, making it easier to manage events and user interactions in a responsive manner.

"Future::IO::Impl::Glib" is a Perl module that serves as an implementation of the Future::IO framework utilizing 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 seamlessly access its implementation methods, enabling them to manage future-based asynchronous tasks with ease. This module is particularly beneficial for those looking to leverage the event-driven capabilities of Glib in their Perl applications without the need for additional methods or complex setups.

"Future::IO::Impl::UV" is a Perl module that provides an implementation of the Future::IO interface using the UV library, enabling asynchronous I/O operations in a non-blocking manner. This module requires no additional methods; simply loading it alongside Future::IO allows developers to utilize its functionality seamlessly. Recent updates include the addition of the `->poll` method in version 0.07, enhancing its capabilities in line with Future::IO v0.19, as well as various bug fixes that improve memory management and compatibility with newer Perl versions. This makes it a valuable tool for developers looking to implement efficient asynchronous I/O in their applications.