CPANscan

Net::Jabber::Bot is a Moose-based Perl class that makes it easy to build XMPP/Jabber bots without deep protocol knowledge by letting you supply server credentials, a simple map of forum triggers, and two callbacks for handling incoming messages and periodic background work. The module handles connecting to chat rooms and users, sending group and personal messages, and provides built-in safety features such as configurable messages-per-second and messages-per-hour limits, maximum message size with automatic chunking, per-forum aliases and a join grace period to avoid reacting to history, and options to ignore server or self messages so you do not accidentally flood or loop. It also supports TLS/SSL configuration including custom CA bundle paths and certificate verification, and includes helpers for presence, roster and simple reconnection logic. Recent releases fixed newline handling in outgoing messages and improved TLS/CA handling and Moose integration. Be aware that some join-failure reporting is limited and disabling safety features can risk unwanted behavior, so keep safety mode enabled until you are confident.

Net::Ident is a compact Perl library for performing ident lookups defined by RFC1413 so you can ask the remote end of a TCP/IP connection which user or ID owns that connection. It offers a simple synchronous API that accepts a connected socket or packed sockaddr pair and returns the remote ID, plus a nonblocking asynchronous object interface you can integrate with select, and optional convenience methods that add ident_lookup to FileHandle or Apache connection objects. Because it uses the ident protocol it requires the remote host to run an ident daemon and that daemon may return opaque IDs for privacy, so results are useful for logging or supplemental access checks but are not guaranteed for every connection. The module is actively maintained and the recent 1.26 release fixes a number of bugs in the async path including a sysread EOF issue that could cause an infinite loop and improves RFC1413 parsing and async reliability.

Regexp::Parser parses Perl regular expressions into an object tree so you can inspect, walk, transform, or reserialize them programmatically. It yields node objects as it parses, provides a walker/iterator to traverse the tree, and can produce a visual string or a real qr// Regexp from the parsed structure while reporting detailed errors and warnings. The module includes support for named character escapes and a handler system for subclassing so you can add analyses or transformations such as min-length checks, character-class operations, or custom rendering. Be aware it parses regex syntax rather than full Perl so variable interpolation in literal strings can be misinterpreted, and early documentation was incomplete though the project has been actively maintained. Recent versions add modern Perl regex features including \K, \R, \h/\H, \v/\V, named captures and backreferences, possessive quantifiers, newer charset flags and caret-reset syntax, and raise the minimum Perl requirement to 5.16.

XML::Parser is a mature Perl interface that makes it easy to parse XML by wrapping the fast Expat library and exposing both high level styles and low level event handlers. You can feed it strings, files or streams and choose a style such as Tree to get a nested parse tree, Subs to dispatch element names to package subs, Stream for streaming canonical output, Debug for inspection, or Objects to build element objects, or you can register custom handlers for start and end tags, character data, declarations and external entities. It supports incremental non‑blocking parsing for streamed input, configurable encodings and namespace handling, and optional external entity fetching with LWP or a file fallback. Handler callbacks receive an Expat parser object and character data is returned as UTF‑8 which may arrive in multiple Char events so callers should accumulate chunks to form full text. Errors during parsing raise exceptions that you can catch with eval and there are options to include contextual lines in error messages. The recent 2.48 release tightened security and robustness by fixing several buffer overflows and large‑file position issues, improved encoding and error reporting, and added a few usability and maintenance enhancements.

YAML::Syck is a thin, fast Perl binding to the libsyck serializer that converts Perl data structures to and from YAML text using simple functions like Load, Dump, LoadFile and DumpFile and supports streaming multiple YAML documents and dumping into existing scalars with DumpInto. It gives you control over common emitter and parser behaviors via global flags such as $YAML::Syck::ImplicitTyping to recognize unquoted booleans and numbers, $YAML::Syck::ImplicitUnicode and $YAML::Syck::ImplicitBinary for Unicode and binary handling, and options to control quoting, sorting keys and whether loaded nodes are blessed into objects. The module implements YAML 1.0 and bundles its own copy of libsyck, so it can be useful when you need interoperability with other Syck wrappers or want a lightweight, speedy YAML layer, but it has some limitations such as incomplete support for dumping glob/IO values and tied variables and a history of known issues and only semi-active maintenance. Recent releases include important stability fixes, notably patches in 2025 that address memory corruption and improve handling of empty strings and keys, but if you need full YAML 1.1 compliance or a more actively maintained YAML stack you may prefer YAML::XS.

CPAN::MetaPackager is a small toolkit for creating and managing a local SQLite copy of the CPAN package index named cpan.metapackager.sqlite. It converts the standard CPAN index file 02packages.details.txt.gz into a searchable, machine-readable SQLite database using the included build scripts, and the distribution even ships a prebuilt database to save the build time. The database is useful when you want a local metadata store for tools such as CPAN::MetaCurator and it includes a converted changelog (Changelog.ini) for easier automation. The project is hosted on GitHub, has support and bug tracking via CPAN/RT, and is released under the Perl 5 license.

CPAN::MetaCurator is a toolset for curating and publishing CPAN and Perl.Wiki metadata as a browsable jsTree-style HTML site. It ingests a Perl.Wiki export (JSON tiddlers), optionally enriches that data from a CPAN::MetaPackager sqlite database, builds a local sqlite store and then exports an HTML tree you can patch into your website. The distribution provides scripts to automate the import, rebuild, export and upload steps so maintainers can refresh a public Perl.Wiki/CPAN listing, though the full import can be time consuming on modest hardware. The project is maintained by Ron Savage on GitHub, is licensed under Perl 5, and offers support via RT or direct email.

Mail::Milter::Authentication is a Perl-based milter daemon that brings a full suite of email authentication and policy checks into your MTA as a single, extensible service. It runs as a preforking Net::Server process and provides a handler framework so you can enable or extend checks like SPF, DKIM, DMARC, ARC, BIMI and RBL lookups, collect metrics, log decisions, and generate or defer DMARC reports. The module is aimed at mail server operators and developers who need a pluggable, production-ready way to apply authentication policies, reject or quarantine mail, and integrate reporting and metrics into their delivery pipeline. It includes daemon control, configurable timeouts and caching, hooks for custom handlers and callbacks, and background dequeue/report processing. Recent notable changes include a new option to perform a separate HELO SPF check and an earlier switch to a stricter Email::Address::XS parser that can change parsing behavior, so users with custom handlers are advised to test configurations after upgrades.

Text::Names::Canonicalize is a Perl module for normalizing personal names in a locale-aware way, useful for data cleaning, deduplication, indexing, and matching. It applies declarative YAML rules per locale to split names into parts and produce a consistent, lowercase canonical form, and it exposes simple functions for getting a canonical string or a structured breakdown showing the original, detected parts, and the canonical result. The rules system supports inheritance between locale files with detection of circular includes, handles multi-word surname particles like "von der" or "d'", and lets you override or extend built-in rules by dropping YAML files in your configuration directory. A command-line tool ships with the distribution and can show explanations of how a name was canonicalized or the resolved ruleset for a locale. Built-in locales include base, en_GB, en_US, fr_FR, and de_DE and you can add more by writing additional YAML rules. This initial release adds the YAML inheritance and circular-include checks, the CLI, user override support, and a multi-word particle tokenizer, and note that the code is provided as-is and the license limits free use to personal single-user scenarios while other uses require contacting the author.

Dist::Zilla::PluginBundle::YANICK is an opinionated collection of Dist::Zilla plugins that reproduces the build and release workflow used by Yanick Champoux, so you can automate packaging, metadata, documentation, testing, Git/GitHub integration, versioning, and CPAN uploads with a single configuration. It wires together contributors tracking, pod and readme handling, license and code-of-conduct files, release tagging and branch management, automatic prereqs, upload/push steps and optional dry-run mode via fake_release, while exposing a few knobs like builder type, authority, development and release branch names, and which extra files to import from the build. If you already use Dist::Zilla and want a ready-made, well-maintained setup that follows common best practices, this bundle saves you the work of assembling many individual plugins, and the 0.32.2 release recently ensured required dependencies are added to the generated dist.ini.

Git::CPAN::Patch is a small command-line toolkit that helps Perl developers grab a distribution from CPAN into a local git repository, make changes in branches, and send those changes back to the module author as patches. It installs a set of git-cpan commands to clone or import CPAN releases, keep a working branch rebased against upstream, format and squash commits into patch files, and submit patches via git-send-email or to RT, so you can use a familiar git workflow when contributing to or maintaining CPAN modules. The tool is designed for Unix-like systems and is not supported on Windows. If an official upstream git repository exists it will use that when available, and the recent 2.5.2 release includes a tweak to avoid signing git tags. This is a practical choice for anyone who wants to move CPAN patching into a git-centric workflow.

Crypt::HSM is a lightweight Perl wrapper for PKCS#11 libraries that lets your Perl code use hardware security modules and software token implementations to manage keys and perform cryptographic operations. It exposes the familiar PKCS#11 concepts of providers, slots, tokens and sessions so you can open a session, authenticate, find or create keys and then run high level operations such as encrypt, decrypt, sign, verify, digest and streaming encrypt/decrypt workflows. The module includes conveniences like loading a specific PKCS#11 library, generating random IVs, searching objects by attributes and handling common mechanisms such as AES-GCM, RSA-OAEP and RSA-PSS while mapping PKCS#11 attributes into Perl objects. Recent releases improved thread-clone safety, made Session and Mechanism objects hold a Slot for clearer ownership, added an id method on objects and relaxed identifier syntax to allow underscores, making it more robust in multithreaded Perl applications. If you need to integrate Perl code with an HSM or SoftHSM for key protection or to offload crypto operations to a PKCS#11 provider, Crypt::HSM is directly relevant and practical.

DBIx::SearchBuilder is an object oriented toolkit for Perl that makes it easy to build, run and paginate SQL queries and to represent returned rows as objects. You write small subclasses that declare the table and record type and the module handles common tasks like limiting and filtering results, ordering and grouping, joining other tables, counting total matches, selecting specific columns, and iterating through pages of results. It can emit the SQL it generates for debugging and supports using bind variables where available. You must provide a DBIx::SearchBuilder::Handle for your database connection and implement NewItem to produce row objects, and the module works with any DBI driver supported by your handle. Use DBIx::SearchBuilder when you want a higher level, reusable abstraction over raw SQL in Perl applications.

Aion::Format is a compact Perl utility collection for everyday text and number presentation tasks, aimed at making logging, console output and simple data formatting easier. It offers ANSI color markup and printing helpers, timestamped access and error logging, number formatting and radix conversion, human-readable byte sizes and intervals, rounding and Roman numeral conversion, lightweight HTML-aware template matching, Russian transliteration helpers, safe capture of STDOUT/STDERR, handy Data::Printer presets and a couple of string-quoting utilities. If you need quick, ready-made routines for coloring, logging, formatting numbers or handling Russian text in command line scripts or small utilities, this module is a good fit.

PlackX::Framework is a compact, Plack-based framework for building PSGI web applications that favors minimalism and extensibility. It wires together lightweight request and response objects with a small router DSL that provides route and filter handlers, and it automatically loads or generates per-application subclasses for handler, request, response, router and related pieces so you can get an app running from a single .psgi file or expand it into separate modules. Requests include a per-request stash and a one-cycle flash cookie, there is optional integration for Template Toolkit and an extended URI helper, and the router uses a Router::Boom based engine under the hood. The project emphasizes fast startup, low memory usage, and few dependencies while leaving heavy customization to subclassing, making it a good fit if you want a simple, performant PSGI foundation rather than a feature-heavy framework. The distribution requires Perl 5.36 or newer and Plack plus a few small modules, is described as experimental/alpha, and this release marks its first CPAN publication.

Hash::Wrap lets you turn plain Perl hashes into lightweight objects so you can access keys as methods instead of manually dereferencing hashes. It works at import time to install a constructor into your package or store it in a scalar, and it gives you options to use the original hash or take a shallow copy or a deep clone, to make accessors lvalue where supported, to recurse into nested hashes, and to make objects immutable or restricted to a fixed set of keys. By default calling an accessor for a missing key throws an exception but you can change that to return undef. The module is designed to be dependency-light and to let you customize class names and add extra methods while tracking additions and deletions to the underlying hash. Note the usual caveats: generated methods may mask keys like DESTROY or AUTOLOAD, lvalue accessors require newer Perls, locked hashes must be copied or cloned before wrapping, and recursive immutability is applied as nested hashes are visited. A recent enhancement in v1.08 adds a -lexical flag to create lexical constructor subs on Perl 5.38 and later.

Text::ASCII::Convert is a Perl module that normalizes text by turning non-ASCII characters into visually similar ASCII characters so you end up with a plain 7-bit ASCII string. It accepts Unicode strings or UTF-8 octets and returns only ASCII bytes, making it useful for spam filtering, search normalization, or any situation where obfuscated text must be reduced to a readable ASCII form. The module maps characters by appearance rather than linguistic meaning, so some mappings can be surprising, for example the German eszett may be mapped to a capital B and Greek Sigma to an E. Characters with no ASCII lookalike are replaced by a single space and runs of spaces are collapsed, zero-width characters are removed, and control characters like tabs and newlines are preserved.

App::GHGen is a command-line tool and GitHub Action that generates, analyzes, and optimizes GitHub Actions workflows for your repositories. It can auto-detect project type or produce language-specific templates for Perl, Node, Python, Rust, Go, Ruby, Docker, and static sites, and it builds workflows with sensible defaults for caching, concurrency, permissions, and testing matrices. The built-in analyzer finds performance, security, cost, and maintenance issues, provides CI-minute cost estimates, and can apply safe auto-fixes or open pull requests with suggested changes so teams can reduce CI time and keep workflows up to date. It integrates into CI to comment on pull requests, create scheduled fix PRs, or act as a workflow quality gate. Perl support includes multi-OS and multi-version testing, CPAN caching via local::lib, optional Perl::Critic and coverage steps, and respect for declared minimum Perl versions. The recent 0.04 release bumped the maximum Perl version, added support for C detection, improved failure behavior when project type cannot be determined, shows debug output on failure, and added analyzer and auto-fix rules for missing timeout-minutes in jobs.

Authen::Radius is a Perl client library for the RADIUS authentication and accounting protocol that makes it easy to send and receive RADIUS requests and responses from your scripts or applications. You can build packets by loading a RADIUS dictionary or by specifying raw attribute types, add and read attributes, use the convenient check_pwd wrapper to verify username/password pairs, control timeouts and retransmits, bind the source IP, and work with RADIUS clusters by providing a node list. The module supports modern RADIUS features such as Message-Authenticator, Status-Server and CoA requests, IPv6 and tagged attributes, and includes a default set of dictionaries so it works out of the box on systems without extra RADIUS components. Recent updates added support for Message-Authenticator values of type "octets", improving compatibility with servers that use that format.

App::Workflow::Lint is a Perl module for linting GitHub Actions workflow YAML files. It provides a programmatic API and is the engine behind the workflow-lint command line, loading a workflow, applying a set of linting rules, and returning diagnostics as hashrefs. You create a linter with new and call check_file to get reported issues or fix_file to apply available fixes and receive the modified workflow plus diagnostics. The module’s POD notes a couple of quirks in the bug section, including limited tablet-detection and that params() returns a reference which callers can mutate. The project is hosted on GitHub and is distributed under licence terms that permit GPL2 for personal single-user use while other uses require a separate licence.

App::ghmulti is a Perl module that provides the functionality behind the ghmulti command-line tool to help you use multiple GitHub accounts with different SSH keys on the same machine. It helps manage how Git and SSH pick the right key and remote configuration so you can work with separate personal, work, or project identities without constantly reconfiguring Git. The module relies on the git command-line tool and integrates with GitHub SSH user data and remote URL parsing, so it is most relevant if you routinely push or pull across repositories tied to different GitHub accounts. For usage details see the ghmulti program documentation and the project repository, and note that git must be installed and available in your PATH.

Net::Async::SOCKS provides lightweight SOCKS5 proxy support for IO::Async by adding an extension that exposes a SOCKS_connect method on your IO::Async::Loop so you can establish TCP connections through a SOCKS5 server from asynchronous code. It is intentionally minimal and designed for simple use cases, making it easy to have your IO::Async loop open proxied connections without changing your architecture. The current implementation only supports IPv4 destination addresses and numeric ports, so it is best suited for straightforward proxying needs rather than advanced SOCKS features. If you already use IO::Async and need a small, no-fuss way to route connections through a SOCKS5 proxy, this module is a convenient option.

IO::Async::SSL adds TLS/SSL support to the IO::Async event loop by plumbing IO::Socket::SSL into IO::Async so you can make nonblocking secure client and server connections or upgrade existing sockets and streams to use TLS. It exposes high-level helpers like SSL_connect, SSL_listen and SSL_upgrade that return futures or accept callbacks, forwards any SSL_* options through to IO::Socket::SSL, and will try to auto-populate verification CA settings from IO::Socket::SSL::default_ca otherwise warning and falling back to no verification. Use this module when you need to add secure transport to an IO::Async-based program without reworking your event loop, and expect it to handle the usual interoperability and error cases while being kept up to date with routine compatibility and bug fixes.

IO::AsyncX::Sendfile is a small, proof-of-concept add-on that injects a sendfile method into IO::Async::Stream so you can stream a file to a socket without copying its contents into Perl memory first, using the kernel sendfile facility via Sys::Sendfile when available. You call it with either a filename or an open filehandle and an optional length, and it returns a Future that resolves to the number of bytes written or fails with an error and details if the send fails. It is intended as a temporary workaround until a more general async file I/O API is merged into IO::Async, so the API may change in future releases.

File::Sticker is a Perl utility for reading and writing file metadata in a consistent way and keeping that information mirrored in a database, making it easy to manage, search and update metadata across many files. It can extract metadata from files using multiple methods, add, delete or replace fields (including multi-value fields), and push or pull metadata to and from a backing database, with convenience methods for searching by tag, listing tags, finding files missing from disk, spotting files not yet in the database, and removing database entries for missing files. The module supports derived values through plugins, picks an appropriate "scribe" for different file types, and includes features for common formats such as ID3v2 tags. Recent releases added a derive-plugins system and improved handling of relative paths, including support for more than one top directory and a bug fix around relative-path derivations, so it is well suited for projects that need robust, extensible metadata management and synchronization.

Mail::Make is a tidy, fluent Perl builder for constructing RFC-compliant MIME email messages without wrestling with low-level details. You compose messages with chainable methods for envelope headers, plain and HTML bodies, inline resources and attachments, and the module picks an appropriate multipart structure automatically while handling non-ASCII headers for you. It is built for real workloads with streaming serialization, optional temp-file spooling to limit peak memory, direct printing to filehandles, and a built-in smtpsend wrapper around Net::SMTP for easy delivery. If you need cryptographic protection it also offers GPG and S/MIME helpers that produce standards-compliant signed and encrypted messages, with GPG able to stream via the external gpg tool and S/MIME using Crypt::SMIME when you can accept in-memory buffering. The recent v0.22.0 release improves the build constructor so attachments can be provided as a single path, a list of paths, structured hashes, or any mix of these for simpler attachment handling.

Data::Hash::Patch::Smart is a small Perl utility for applying structured, JSON-Pointer-like patches to nested Perl data structures, letting you add, change, or remove values with path expressions and wildcards rather than hand-editing hashes and arrays. It supports both ordered and unordered array semantics, structural wildcards that match multiple children, an option to auto-create missing intermediate containers, a strict mode that validates paths and indices, and cycle-safe wildcard traversal, and it returns a deep-cloned copy with the changes applied. Its main uses are configuration management, data migrations, and round-tripping diffs and patches, and it is driven by a simple patch( $data, \@changes, %opts ) call. This initial CPAN release documents and tests those features and adds support for wildcards, unordered arrays, strict validation, create_missing behavior, and cycle-safe traversal.

Modern::Perl::Prelude is a small lexical prelude that gives you a ready set of modern Perl conveniences while staying runnable on Perl 5.30 and later. It enables strict and warnings, brings features like say, state and fc into the caller, provides try/catch compatibility and imports handy functions such as blessed, refaddr, reftype, trim, ceil, floor, true/false and weakref helpers so you can write cleaner, more idiomatic code without hand-rolling boilerplate. You can opt into source-level UTF-8 or into backported class and defer syntax with the -utf8, -class and -defer flags and those extra compatibility layers are lazy-loaded so they only load when you ask for them. no Modern::Perl::Prelude reliably turns off the native pragmata it manages but backported feature modules are treated as import-only and may not be symmetrically undone. Recent updates added the optional -class and -defer imports and improved unimport behavior while keeping default behavior unchanged.

Bitcoin::Crypto is a Perl library that provides the cryptographic building blocks and utilities needed to work with Bitcoin keys, mnemonics, address formats, scripts, transactions, PSBTs, blocks and UTXOs. It supports generating BIP39 mnemonics and deriving BIP32/BIP44 extended keys and also exposes lower level primitives for public and private keys, signatures, encodings and script handling so you can create, parse and manipulate raw Bitcoin data structures. The distribution offers convenient shortcut imports that load the relevant object classes on demand, making it easy to instantiate extprv/extpub, basic keys, script trees, transactions and PSBTs without boilerplate. This module is a good fit for Perl developers building wallets, signing tools, transaction constructors or any application that needs direct control over Bitcoin cryptography and data formats. For network RPC work see Bitcoin::RPC::Client and consult Bitcoin::Crypto::Manual for detailed usage.

Config::Model::Itself is a helper library for people who build and maintain Config::Model schemas; it gives you a programmatic way to load, edit and save the model files that describe the structure and rules of configuration data. The module exposes an object for reading all model files from a directory tree, filtering or force-loading broken files, writing models back while preserving layout, emitting model plugins, and producing Graphviz dot diagrams and class/element listings. It is useful if you create, test or distribute Config::Model-based configuration schemas or want to drive the model editor from scripts or the cme tool and its Tk or Curses UIs. One known limitation is that test menu entries are generated from the application list and cannot be updated without restarting cme. Recent work keeps compatibility with evolving Config::Model and UI components and release 2.028 fixes a backend detection problem introduced in 2.027.