CPANscan

Genealogy::Relationship::Name is a compact Perl module that turns two generational step counts plus the sex of a person into a human-readable kinship name, for example "first cousin once-removed", and can localize the result into several languages. You construct a namer object with an optional default language, optional Log::Abstraction logger, or an Object::Configure config file, then call name() with steps_to_ancestor, steps_from_ancestor, sex and optional per-call language and family_side to distinguish maternal versus paternal terms where available. The module ships lookup tables for English, German, Spanish, Farsi, French and some Classical Latin terms and provides helpers to list supported languages and valid sex codes. Calls return a localized string or undef when a particular step combination is not in the table. Note that the included tables cover steps 0 through 6 in each direction so very distant relationships are not yet tabulated and Latin coverage is sparse.

PAGI is a modern asynchronous web application specification and toolkit for Perl that brings async/await programming to the web as a spiritual successor to PSGI. It defines a small, stable app interface where an async coderef receives a scope, a receive callback and a send callback and it supports HTTP/1.1, WebSocket and Server Sent Events plus process lifecycle events. The distribution bundles a reference server, convenience helpers for requests, responses, WebSocket and SSE handling, routers, middleware and example apps so you can build and test async services quickly. The PAGI spec and the reference server are intended to be stable while many helper modules and routers are still evolving, so expect some APIs to change as the project matures. PAGI addresses practical concerns such as UTF8 handling, send-side backpressure and loop interoperability and requires Perl 5.18 or later with IO::Async and Future::AsyncAwait. A notable recent change is the new PAGI::Context factory that provides a unified context object and introduced updated endpoint handler signatures along with improved stash and session helpers, so review the changelog before upgrading. If you want an evented, futures based approach to building web services in Perl PAGI is worth evaluating.

Mojolicious::Plugin::Statsd is a small, easy plugin for Mojolicious apps that gives you a convenient helper to emit counters, timings, gauges and set updates to a StatsD-compatible server. You call the helper from controllers or hooks to increment or decrement counters, time blocks of code either by passing a duration or a coderef, send gauge values and add members to sets, with optional sampling and a with_prefix helper to scope metric names. The plugin is adapter-based so you can switch backends or use the bundled in-memory adapter for testing, and by default it emits UDP packets to localhost:8125; recent versions added a client attribute and now use Net::Statsd::Tiny for protocol handling. Configuration lets you change the helper name and prefix and pass options to the adapter, and the module requires Perl v5.16 or later. The 0.06 release fixed a metric-injection security issue and adds a security policy so take care not to expose sensitive data in metrics and to sanitize names to avoid colons or pipes used by the StatsD protocol.

EV::ClickHouse is an async, XS-based ClickHouse client for Perl that plugs into the EV event loop and speaks both the HTTP and native TCP protocols without requiring an external client library. It is designed for high-throughput, nonblocking access: you can run parameterized queries, stream large results via per-block callbacks or a synchronous iterator, and push bulk inserts with a buffered insert_streamer that handles batching and backpressure. The client offers connection-level and per-query settings, automatic reconnect with backoff, optional compression and TLS (including mutual auth), raw HTTP bodies for CSV or Parquet, and typed decoding for many ClickHouse column types. For multi-node deployments there is built-in multi-host failover and, in the latest release, a full connection pool with circuit-breaker, hedged queries, fan-out and session pinning, plus async DNS, retry helpers, external-table support and idempotent/async insert helpers. If you are writing Perl services or ETL pipelines that need low-latency, event-driven access to ClickHouse this module provides a production-oriented feature set and tooling to handle streaming, retries, and operational concerns.

String::Obfuscate provides a fast, reversible substitution cipher to scramble text for non-security-sensitive purposes. It builds a reproducible character mapping from a numeric seed or passphrase via the ISAAC random generator so you can decode what you encoded by reusing the same seed. By default it shuffles ASCII letters and digits but you can supply your own character set or use the included Base64 and Base64::URL subclasses for binary or UTF-8 data. The module is explicitly not cryptographically secure, but it is far faster than full encryption and generates compact encode/decode routines that can be dumped for inspection. It requires Perl 5.20 or later and optionally uses List::Util::XS for a deterministic shuffle. Use this module when you need lightweight, reversible obfuscation of IDs, test data, or configuration values rather than protection of secrets.

HTML::Gumbo is a thin Perl wrapper around Google's Gumbo C library that brings a standards‑compliant HTML5 parser to Perl programs. It can parse HTML into a cleaned, balanced string, drive a callback stream of parse events for streaming or token-level processing, or produce an experimental HTML::Element-based tree for DOM-like access. The module accepts decoded Perl strings or raw octets and offers options to control how character encoding is handled, and it is designed to be robust against malformed input and lightweight in use. A few features are still incomplete or experimental, for example tree output is alpha, some library features like source locations are not exposed, and automatic encoding sniffing and prescan are not implemented. If you need reliable, spec-accurate HTML5 parsing from Perl with simple APIs for string output or event callbacks, HTML::Gumbo is a practical choice.

Catalyst::Plugin::Authentication provides the core authentication and basic authorization infrastructure for Catalyst web applications. It lets you define one or more realms that pair a credential verifier with a user store so your app can authenticate users and look up their data, and it integrates with Catalyst sessions so login state can persist across requests. You configure realms in your app and then use simple methods such as $c->authenticate, $c->user, $c->user_exists and $c->logout to manage login flow. The plugin works with many storage backends and credential modules, from a simple in-memory hash to DBIx::Class or LDAP stores and Password, HTTP or OpenID credential handlers, so you can change storage without rewriting your app. Note that since version 0.10 it uses a realms-based API and older credential or store modules must be updated or used in a compatibility mode that disables realm features. Overall this is the standard, flexible glue for adding user authentication to Catalyst apps and integrates with other Catalyst authorization and session plugins.

Template::Toolkit is a mature, Perl-based template processing system for generating any kind of text output, most commonly static and dynamic web pages. It cleanly separates presentation from application logic so designers can build and edit templates without touching Perl code while developers can integrate and extend the toolkit through plugins and APIs. The system is input-agnostic and works with HTML, XML, CSS, JavaScript, plain text and more. Non-Perl users can easily author templates and Perl developers can hook Template::Toolkit into existing code or use the bundled command-line tools tpage and ttree to process files or directories. Extensive POD documentation, tutorials and a rich module/plugin ecosystem make it straightforward to learn, adapt and deploy for a wide range of templating needs.

Dist::PolicyFiles is a tiny utility for Perl authors that automates creating CONTRIBUTING.md and SECURITY.md files for a distribution. You give it your GitHub login and module name and it fills in sensible defaults and links such as CPAN request tracker and a GitHub issue/SECURITY.md URL, can pull your name and email from SSH config, and lets you supply or override a CONTRIBUTING.md template. The security file generation delegates to Software::Security::Policy::Individual so you get a standard policy layout with configurable maintainer, program and URL values, including options to add a repo prefix or force lowercasing. It also ships a dist-policyfiles command line tool for convenience. The recent 0.09 release added helper methods to return the CPAN RT URL, the computed repo name and the GitHub repo URL.

App::FatPacker::Simple is a focused utility for turning a Perl script and a set of known module files into a single bundled script for easy distribution and deployment. Unlike fuller fatpacking tools it does not try to trace dependencies for you, so it is best when you already understand what needs to be included; it concentrates on embedding modules from directories, offers automatic perl-strip support to remove unneeded code, and provides options to exclude specific modules from the bundle. You interact with it via the fatpack-simple command and a short tutorial is available, making it a lightweight, controlled way to produce standalone Perl scripts. Recent releases raised the minimum required Perl to 5.24 and improved packaging to exclude authoring files from release archives.

WWW::RobotRules is a small utility for parsing robots.txt files and keeping a local database of the resulting access rules so your crawler can ask whether a given URL is allowed for a named robot. You create a WWW::RobotRules object with your agent name, feed it the contents of robots.txt files from one or more hosts, and then call allowed($url) to decide whether to fetch that URL. The module supports the standard User-agent and Disallow records and will apply the most specific matching rule for each agent, and changing the agent name resets the cached rules. Recent updates hardened on-disk cache handling to avoid a symlink race and tightened file permissions, but note there remains a caller-trust requirement because the underlying AnyDBM_File tie follows symlinks on platforms that do not provide O_NOFOLLOW, so you should keep the cache file in a directory writable only by the crawling user.

AtteanX::Endpoint provides a PSGI-compatible SPARQL 1.1 Protocol endpoint that you can mount in a Plack-based web app to expose an Attean RDF model over HTTP, accepting SPARQL requests, invoking the planner and model to evaluate them, and returning PSGI responses via its run($request) method. The module is driven by a configurable conf hash so you can control the service description, choose whether to expose named and default graphs, enable or disable data loading and update support, and set the default graph IRI. It also includes simple logging hooks for queries and errors. Use this module when you want a lightweight, Perl-native SPARQL endpoint for serving or integrating RDF stores into web services and applications.

CLI::Simple is a compact, object‑oriented helper for writing Perl command‑line programs that need options, subcommands and positional arguments while staying lightweight and testable. It is built around the modulino pattern so a single module can act as both a reusable library and an executable script, and it auto-creates getter/setter accessors for options, integrates Log::Log4perl for logging with optional per-command log levels, supports aliases and abbreviated commands, and exposes handy internal tools to introspect a live modulino, dump a YAML manifest, scaffold role stubs, migrate to a role-based layout, and generate bash completion scripts. For larger projects it offers an optional role-based workflow where commands and options live in a YAML manifest and are implemented as Role::Tiny roles, letting you move from a simple script to a composable, distribution-friendly layout with minimal fuss. It is aimed at internal tools and small to medium CLIs where you want structure without a heavyweight framework, and the 2.0.x series notably added the manifest/role architecture plus scaffolding and completion tools while the 2.0.2 release made a few packaging and shell usage improvements.

Log::Dispatch::UDP is a small Log::Dispatch output class that sends plain text log messages from a Perl program to a remote UDP socket. It plugs into the Log::Dispatch framework so you can route info or higher level events to a hostname and port and the datagrams contain just the message text, making it simple to capture with tools like netcat or a lightweight UDP collector. Because traffic is sent unencrypted and unstructured, it is best suited for non-sensitive, low-overhead remote logging rather than secure or audited record keeping. The module requires Perl 5.8 or later and only the latest release is supported. The recent 0.02 maintenance release added a new maintainer, a security policy and explicit security considerations, strengthened prerequisite version minimums, cleaned up unused code and added author tests.

App::MARC::Validator is a small base class that provides the application-level framework for a command line MARC record validator. It exposes a simple constructor and a run method that executes validation and returns 0 for success or 1 for error, and it ties together existing MARC libraries and helpers so you can quickly build or extend a validator script for library and archival metadata workflows. The module is aimed at developers and metadata engineers who want an application wrapper rather than a low level parser and is distributed on GitHub under a BSD 2-Clause license.

Config::Writer is a compact Perl utility for safely creating and updating configuration files by writing to a temporary file and then atomically replacing the real file, with built-in support for setting file owner, group and permissions and for making timestamped backups with automatic rotation. You use new to create a writer object pointing at a target filename and work directory and then print, printf, say or sayf to write into the temp file or hand fh to template engines, and close to commit the change, move the old file to a backup name, and prune old backups according to the retain and overwrite options. The module supports configurable backup filename extensions that use strftime formats, explicit owner, group and permission settings, and easy error checking via error, so it fits well where you need safe, repeatable config updates on a system. It requires Perl 5.10 or newer because it uses the signatures feature. The latest release added convenience getter methods to read back object properties such as filename, fullname, tmpfile and workdir.

App::cpan2arch is a Perl module that implements the core logic of the cpan2arch tool so you can turn CPAN distributions into Arch Linux PKGBUILD files. It queries MetaCPAN for module and distribution metadata, translates CPAN prerequisites into PKGBUILD dependency syntax, checks whether those prerequisites already exist in Arch official repos or the AUR, and then generates a ready-to-use PKGBUILD to stdout or a file. Use it by constructing an object, calling init to read environment and command-line options, and calling run to perform the fetch, conversion, checks, and output; run returns 0 on success. The module reports network, JSON, file, and other errors to STDERR and exits with a nonzero status when problems occur. This is useful for Perl authors and packagers who want an automated, metadata-driven way to create Arch packages from CPAN modules.

Module::Starter::PBP is a simple plugin for Module::Starter that creates a ready-made Perl module distribution layout following the recommendations from Damian Conway's book "Perl Best Practices". It installs a set of default templates for files like Build.PL, Makefile.PL, README, Changes, the main .pm file and test scripts, and fills in placeholders such as author, email, module name and copyright year from your Module::Starter config. You can run perl -MModule::Starter::PBP=setup to create a template directory and populate your ~/.module-starter/config, and thereafter create new modules with module-starter --module=Your::New::Module. The module requires Module::Starter and is aimed at authors who want a consistent, book-aligned project skeleton without handcrafting every file.

Config::Abstraction is a Perl module that provides a simple layered configuration layer for applications and libraries, letting you load defaults from in-memory hashes, merge settings from files in common formats (YAML, JSON, XML, INI), and then override those values from environment variables and command line arguments with predictable precedence. It exposes a uniform API with dotted-key access, optional flattening, AUTOLOAD convenience methods, configurable environment prefixes where double underscores map to nested keys, and automatic discovery of sensible config directories while recording which files were used. The module supports schema validation and pluggable logging, and aims to keep configuration flexible and easy to override at runtime without embedding file-format handling in your code. Recent updates make file loading more robust by warning and skipping malformed YAML/JSON files instead of failing construction and by fixing corruption of coderefs and blessed objects passed as default data. If you want a straightforward way to centralize and layer configuration from multiple sources in Perl, this module is likely relevant, though escaping the key separator and Windows environment case sensitivity are noted caveats.

Mail::Milter::Authentication is a Perl milter server framework that implements email authentication standards and provides the preforking daemon infrastructure needed to plug those checks into an MTA. It manages the server lifecycle, child processes, logging and lifecycle hooks while delegating protocol specifics to Mail::Milter::Authentication::Protocol::* classes and per-message logic to Mail::Milter::Authentication::Handler modules. The module can preload and dynamically load handlers, register and sort callbacks for correct dispatch order, run metrics-aware request processing, toggle extra debugging, and notify administrators by email on fatal conditions, and it exposes simple control methods to start, stop and manage the daemon. If you run or develop mail server tooling and want a ready-made, extensible Perl server for enforcing SPF, DKIM, DMARC and related checks, this package provides the server-side plumbing so you can focus on the policy and handler logic.

RT-Extension-ExcelFeed is a plugin for Request Tracker that lets you export query results and scheduled dashboard reports as Microsoft Excel .xlsx files. It adds an "MS Excel" option to the Feeds menu on Query Builder results and lets dashboard subscriptions send scheduled reports as attached spreadsheets instead of inline HTML, making it easier to share, analyze, and archive RT data in familiar spreadsheet tools. The extension works with RT 6.0 (use the 0.* series for RT 5), is installed as a standard RT plugin, and includes a configuration toggle to hide the chart download button if you do not want that option shown.

Time::Str is a Perl library for reliably parsing and formatting date and time strings across a wide range of standards. It gives you str2time to turn timestamp strings into Unix epoch seconds, str2date to extract parsed components without requiring a resolved timezone, and time2str to render epochs back into RFC3339, RFC2822, HTTP, SQL, ASN.1 and many other formats. It handles fractional seconds with configurable precision and an exact nanosecond override, includes a permissive DateTime-style parser for many real world inputs, and reports timezone details while intentionally leaving ambiguous abbreviations unresolved so you can decide how to handle them. The module ships with a fast XS backend and a pure-Perl fallback and works smoothly with DateTime and Time::Moment. Note the limitations of the module are English-only month and day names, no ISO week or ordinal dates, a supported year range of 0001 to 9999, and no automatic resolution of timezone abbreviations.

Quiq is a comprehensive, actively maintained Perl class library that provides more than 260 small, focused modules to speed application development. It collects reusable utilities for common needs such as filesystem and path operations, database access and result sets, HTTP/IMAP/SMTP clients, HTML and JavaScript generation, image and plotting helpers, time and date handling, XML and JSON processing, caching, parallel and process utilities, and even domain-specific tools like ZUGFeRD e-invoicing, Confluence/MediaWiki clients and wrappers for ffmpeg, rsync and ImageMagick. The components are designed to be used independently with consistent conventions so you can pick what you need instead of reinventing boilerplate. The distribution is available on CPAN (cpanm Quiq) and is maintained by Frank Seitz under the same license terms as Perl. The latest release improves UTF-8 handling in debug diffs and updates the ZUGFeRD templates and related entity classes.

App::Netdisco is an open source, web‑based network management application that helps network teams discover, inventory and control their switching and routing infrastructure by collecting SNMP and related data into a PostgreSQL database. It makes it easy to locate a device or host by MAC or IP and see the exact switch port, to change port properties such as VLAN or PoE state, and to build searchable inventories by vendor, model and OS while visualising topology with neighbour maps. The package includes a web frontend with its own server, a backend daemon for scheduled polling and interactive jobs, a command line tool for ad hoc actions, an extensible plugin system and a documented API. Installers will want Perl 5.10+ and PostgreSQL 9.6+, and container images and an online demo are available for evaluation. Recent releases migrated the public demo hosting to DigitalOcean and updated Python dependencies for security fixes.

Muster is a lightweight content management web application written in Perl that helps you create, edit, and serve site pages. It is built on the Mojolicious web framework and uses the Mojolicious::Plugin::Foil templating plugin, so developers get familiar routing and rendering tools out of the box. Muster is most useful as a simple, extensible CMS or as a starting point for Perl developers who want to prototype or host content-driven sites without adopting a large, full featured platform.

File::Sticker is a Perl library for reading and writing file metadata and keeping a synchronized database of that information so you can index, tag and manage large collections of media and documents. It extracts metadata from a variety of formats and can add, replace or remove fields inside files, derive new values through plugins, and update a central database for searching and reporting. The module also offers database-oriented tools for tag-based searches, querying a file's database record versus its embedded metadata, finding missing or overlooked files, and bulk updating or deleting entries. A format-aware "scribe" layer picks the right reader and writer for each file so you do not need format-specific code. Recent updates improve EXIF parsing and treat EPUBs separately, add derived-value plugins, allow multiple top directories for relative paths, and introduce fields like create_date and alt_text along with ID3 v2.4 mood tag support, making it a practical choice for organizing and synchronizing metadata across diverse file types.

XML::Parser is a Perl interface to the Expat XML library that gives you flexible, event-driven parsing for strings, files, and streams. You can install callback handlers for start and end tags, character data, declarations and external entities, or choose one of the built-in styles to get a parse tree, object nodes, simple subs-per-element dispatch, or a streaming canonicalizer. It handles encodings and external-entity fetching, supports incremental nonblocking parsing, and reports parse errors as exceptions with optional contextual lines for debugging. Modern Expat security knobs for defending against XML bombs and allocation attacks are exposed as constructor options. Use XML::Parser when you want a lightweight, low-level Perl parser with fine-grained control over parsing behavior and multiple convenient parsing styles.

Developer::Dashboard is a local developer home that brings your browser pages, prompt status, CLI helpers, saved notes, path aliases, quick file open commands, Docker Compose helpers and repeatable checks into one consistent runtime so you do not scatter scripts, tabs and bookmarks across the system. It stores a layered runtime under ~/.developer-dashboard with optional project-local ./.developer-dashboard overlays so the web UI, shell prompt and CLI all read the same prepared state; saved pages can include Template Toolkit HTML and executable CODE blocks, background collectors prepare cached stdout/stderr and exit codes for cheap prompt and browser indicators, and built-in query tools let you inspect JSON, YAML, TOML and Java properties from the command line. The bundled web server listens by default on port 7890 and implements a deliberate access model that treats loopback requests as local admin while requiring helper logins for non-loopback access and keeping transient token execution disabled by default for safety. Runtime-managed helper scripts are staged privately so dashboard-owned commands do not pollute the global PATH and an extendable skills system lets you install isolated repo plugins that add pages, collectors, CLI commands and Docker compose roots. The project is language agnostic enough to help mixed-language teams and polyglot repositories and recent releases hardened home runtime permissions, improved collector watchdog supervision and restart behavior, and sped up thin helper commands by memoizing PathRegistry cwd lookups to avoid redoing layered path discovery.

Module::Generic is a comprehensive base class designed to speed the development of Perl object APIs by providing a large set of reusable helpers for common data types and patterns, including automatic getter/setter generators, rich _set_get_* accessors for scalars, numbers, booleans, dates, files, URIs and UUIDs, object and array factories, dynamic class creation via create_class, and an AUTOLOAD that turns hash keys into methods so you can build feature-rich objects with minimal boilerplate. It also includes utilities for error and exception handling, structured debug and colourised terminal output, convenient serialization/deserialization hooks for CBOR, Sereal and Storable::Improved, and optional XS-accelerated primitives for better performance when the XS layer is available. The distribution provides many companion classes (Array, Scalar, Number, Null, File, etc.) and implements thread- and process-safe global storage for errors, while documenting important caveats where certain runtime metaprogramming operations such as injecting package symbols or creating dynamic classes should be performed before threads are spawned. The recent v1.5.0 release relaxed the minimum Perl requirement to 5.16, added a class-wide _in_global_destruction helper for safer DESTROY handling, and included portability fixes in the Number code path, making the framework easier to use on older Perls and more robust across versions.

XML::LibXML is a mature Perl binding to the libxml2 library that gives you fast, standards‑compliant XML and HTML parsing plus full access to DOM, SAX and pull‑style XMLReader APIs along with XPath and schema validation features. It provides familiar document and node classes for creating, traversing and manipulating XML trees, helpers for DTD, RelaxNG and W3C Schema validation, and facilities for custom input callbacks and encoding conversion while leaving low‑level encoding work to libxml2. The module exposes useful constants and version checks, offers partial thread support with an option for shared nodes, and includes experimental helpers to interoperate with XML::GDOME. Use XML::LibXML when you need robust parsing, querying or validation of XML/HTML in Perl, but be aware that encoding support depends on your platform libraries and problems have been reported on systems with broken iconv installs.