CPANscan

Metrics::Any::Adapter::Statsd is a lightweight Metrics::Any adapter that sends metrics to a statsd server over UDP, emitting each metric as its own UDP packet to a configurable host and port (default 127.0.0.1:8125). Counters, gauges and timings are translated to standard statsd formats and multipart metric names are joined with periods, while distribution observations are emitted as two submetrics named count and sum. This adapter does not preserve labels and will collapse labeled values into a single aggregate, so labeled gauges may not be useful and you should consider the DogStatsd or SignalFx adapters if you need tagging. Recent releases tightened documentation and tests and fixed several CVEs related to disallowed characters in metric and label names. The module is a practical choice for simple unlabelled statsd reporting but does not yet support non-default sampling-rate emission or richer labeling.

BATsh is a pure-Perl bilingual shell interpreter that lets you write and run scripts mixing Windows cmd.exe batch syntax and Unix bash/sh syntax in the same file with automatic, line-by-line switching and a shared variable store. You can run script files, execute inline source strings, or drop into an interactive REPL, and the module implements many common CMD and SH builtins such as SET, IF, FOR, functions, pipelines, redirection, command substitution and parameter expansions so typical cross-platform shell logic runs inside Perl without invoking an external shell. Nonbuiltins are still launched as external programs via the host OS so tools like FINDSTR or SORT work only if the corresponding executable exists on the platform. Not everything from either shell is reimplemented though, so some CMD features like variable substring expansion and dynamic pseudo-variables are missing and the SH side lacks arrays, filename globbing, tilde and brace expansion, process substitution, full job control and a few other advanced features, and parenthesized groups do not create isolated subshells. If you need a portable way to combine batch and shell styles inside Perl scripts or to prototype mixed-mode scripts without installing separate shells, BATsh is a compact, self-contained option and its source and issue tracker are on GitHub.

Mojolicious::Plugin::OpenAPI lets you drive a Mojolicious web app from an OpenAPI/Swagger document by automatically adding routes and performing request and response validation against the API spec. It supports OpenAPI v2 and v3 though v3 may not implement every feature, and it exposes helpers such as openapi.valid_input and openapi.spec plus a special openapi renderer that validates and formats responses before they are sent. The plugin is extensible with bundled plugins for CORS, security and spec rendering and offers configuration options for routing, coercion and output formatting so you can adapt it to protected APIs or custom renderers. Recent releases improved multipart/form-data handling by combining body parameters and uploads for easier file and form processing. If you want your Mojolicious app to follow a formal API contract and get automatic validation, documentation endpoints and convenient helpers, this plugin is a solid, actively maintained option.

Test::Against::Dev is a practical tool for checking whether monthly Perl development releases break the installability of selected CPAN modules. It automates downloading a dev tarball, building and installing that perl, fetching a cpanm, running installs for a curated module list or a CPAN River file, and then parses the build logs into per-module JSON and a pipe-separated summary that records PASS or FAIL for each module and release for easy spreadsheet analysis. The workflow is intended to run on a stable Unix host under your control rather than relying on CPANtesters infrastructure so you can monitor the specific modules that matter to you or your organization. The module has a number of CPAN dependencies and is designed for Unix environments so it is not expected to work on Windows or VMS. In the latest release the package stopped using FTP and the Perl::Download::FTP dependency so tarballs are now obtained via HTTP(S).

Storable is a fast, widely used Perl module for serializing and persisting complex Perl data structures to files, sockets or memory so you can save and later restore hashes, arrays, scalars and references. It provides simple procedural routines like store and retrieve for disk files, nstore for portable network order, store_fd/fd_retrieve for working with open filehandles, freeze and thaw for in-memory serialization and dclone for deep cloning. Object classes can customize how their instances are serialized and restored via STORABLE_freeze and STORABLE_thaw or attach hooks, and lock_store/lock_retrieve offer advisory file locking. The core is implemented in C for speed and it supports canonical ordering for reproducible dumps and optional CODE reference serialization via deparsing. Be aware that Storable is not safe for untrusted input because deserialization can load modules, run code or trigger destructors, and it cannot handle some types like GLOBs and certain regex constructs reliably; also references used as hash keys do not survive round trips exactly. Use Storable when you need efficient persistence, fast IPC or convenient deep cloning of Perl data, but avoid accepting Storable documents from unknown sources.

Concierge is a lightweight service-layer orchestrator that bundles password authentication, session lifecycle, and user record storage into a single, easy-to-use API so applications can manage visitors, guests, and logged-in users without wiring the pieces together themselves. It uses Argon2 for credential hashing, supports SQLite, file, or in-memory session backends and multiple user-store backends (SQLite, YAML, CSV/TSV), enforces one active session per user, and tracks active clients with a persistent user_key mapping stored in a desk directory. Typical use cases include issuing anonymous visitor IDs, creating temporary guest sessions for carts, converting guests into authenticated users, and performing admin tasks like adding, listing, or removing users while keeping credentials out of the user record. The design is intentionally modular so you can drop in alternate Auth, Sessions, or Users components that implement the same method contracts or add new record-store components following the provided base class. The recent 0.8.4 release focuses on documentation improvements for desk setup, adding UI formatting hints and a format_as field attribute to help render user fields in client templates.

Net::Correios is a Perl client for the Brazilian postal service REST API that makes it easy to look up CEPs, compute shipping prices and delivery times, track packages and manage pre-postage, manifests and contract-related queries. It automatically handles API authentication and token renewal, supports both sandbox and production endpoints, and offers a debug mode that prints equivalent curl commands and raw responses for troubleshooting. To use it you must have a commercial contract with Correios and an API key obtained from their portal. Documentation is provided in Portuguese and a few features such as invoices and agencies are listed as TBD.

HTTP::Message is the core Perl class for representing an HTTP-style message made of headers and a content body, and is the foundation for HTTP::Request and HTTP::Response. It gives you easy creation and parsing of messages, direct access to headers via an embedded HTTP::Headers object, efficient manipulation of large bodies through content_ref, and helpers for adding, encoding and decoding content including common compression formats and charset-aware decoding for text and XML payloads. The module also understands multipart and message/* containers and lets you work with message parts, clone or stringify messages, and produce safe diagnostic dumps. One important detail is that decoded_content focuses on text and XML types and does not automatically decode declared charsets for other types like application/json, and it will return undef on unknown encodings unless you ask it to raise an error. The recent 7.02 release adds handling for the unusual HTTP method "0" and prior fixes improved as_string/parse behavior.

Concierge::Users is a service-style Perl module for managing user records with a configurable field schema and pluggable storage backends, letting you define core, standard, system, and application-specific fields at a one-time setup step and then load that configuration at runtime to perform CRUD operations. It supports SQLite (recommended for production), simple CSV/TSV flat files, or one-YAML-file-per-user storage, and it validates field values on create and update with a variety of validators (email, phone, date, boolean, enum, moniker, name, etc.) while allowing validation to be skipped for bulk imports via an environment flag. All public methods return structured hashrefs with a success flag and messages so callers can handle errors predictably, and the module includes a small filter DSL for listing users and automatic archiving of existing data when you re-run setup to avoid data loss. The module is part of the Concierge suite but works standalone and supports extensive field customization and overrides so you can adapt enums, defaults, and application fields to your needs. The recent v0.9.0 release added a format_as property on built-in fields and exposes it via get_field_hints so applications can carry native format hints (text, options, boolean, number, date, datetime, time) alongside the schema.

Quote::Code adds three handy quoting constructs to Perl called qc, qc_to and qcw that make it easy to embed computed values directly inside literal strings and word lists. qc behaves like a mix of q and qq by recognizing backslash escapes but not interpolating variables, while letting you place arbitrary Perl expressions in {...} which are evaluated in scalar context. qc_to provides a heredoc-style form for longer text and uses Ruby-like #{...} for interpolation so ordinary braces do not need escaping. qcw is like qw but produces lists of words with code interpolation, supports backslash escapes and lets you escape spaces inside words. These features simplify and clarify string construction compared with older @{[ ... ]} tricks. The latest maintenance release fixed a crash when the module was loaded at runtime by multiple threads and relocated the project to Codeberg.

Config::Model::Itself is the meta‑model editor for Config::Model that lets you read, inspect and write the schema files that describe configuration structures, so you can treat a configuration model itself as editable data. You create an Itself object, load model files with read_all, make changes via provided command‑line or GUI tools such as the cme meta editor or a Curses/Tk UI, and save the result with write_all while preserving the original directory layout; it can also generate graphviz dot diagrams of class relationships and read or write model plugins for distribution. The module supports force-loading of imperfect models, can list classes and elements for debugging, and integrates with the cme meta command to provide edit, check and dump operations. A known limitation is that test menu entries are built from model content at startup so changing the application list requires restarting cme to refresh the menu. The recent 2.031 release adds a -factorize option to reduce written model size by using Config::Model factorization features, updates several element models, ensures written files include "use utf8;", and requires Config::Model 2.163 or newer.

Config::Model is a Perl framework for declaring, validating, migrating and editing application configuration using a declarative model. You describe your configuration structure and constraints as Perl data structures and the framework provides readers and writers for common formats, a validation engine, and generated user interfaces including a shell, curses and Tk front ends. It separates the model from processing code so the same declarative schema drives interactive editors, automated upgrades and validation rules. The project includes a command line tool (cme), a GUI model editor (Config::Model::Itself) and multiple backends such as INI, shell-var, plain files and Augeas, and the API lets you create and manipulate models and instances programmatically, making it a good fit for projects that need consistent, maintainable configuration handling and interactive editing across environments.

App::Cme is a model-driven command line tool for checking and editing configuration data that builds on the Config::Model framework. It applies formal configuration models to validate the syntax and semantics of config files, highlights problems, and can be used to make controlled edits so your configuration stays consistent with expected constraints. The tool is aimed at developers and system administrators who want automated, repeatable checks or guided edits of configuration files, and it is open source under the LGPL with sources and issue tracking available on GitHub.

Sys::Virt is a Perl XS binding for the libvirt virtualization API that lets Perl programs connect to and manage hypervisors and their resources. You create a connection with a libvirt URI and then use the connection object to list, create, define and control domains, networks, storage pools, interfaces and host devices, to query host capabilities, CPU and memory statistics, and to convert between native hypervisor formats and libvirt XML. The module supports authenticated and readonly connections, provides rich event registration for domains, networks, storage pools, node devices and secrets, and uses Sys::Virt::Error exceptions for failure handling. Be sure to deregister any callbacks so the connection can be garbage collected. The author notes the XS layer should be audited to ensure it is not leaking memory.

App::Netdisco packages Netdisco, an open source web-based network management tool that collects SNMP data into a PostgreSQL database and provides a browser interface plus a backend daemon for discovery and control. It helps you find a machine by MAC or IP and shows the exact switch port, perform port actions such as shutting down a port or changing VLAN and PoE settings, inventory hardware by model and vendor, and produce visual topology maps. The distribution includes command line utilities for discovery and automation, a DBIx::Class database API for developers, and a plugin system to extend the web UI and backend, and there are official container images and an online demo to try. Netdisco requires Perl 5.10 or later and PostgreSQL 9.6 or later and ships detailed installation, upgrade and troubleshooting documentation.

Protocol::OVSDB is a Perl implementation of RFC 7047 that lets applications communicate with Open vSwitch and OVN database engines using the OVSDB protocol. It exposes low-level request/response and notification handling plus convenient RPC-style methods for listing databases, fetching schemas, performing transactions, installing monitors, acquiring or stealing server-wide locks, and sending echo checks. The module is transport-agnostic so it does not open sockets itself; you provide an on_send callback to deliver outgoing bytes and call receive with incoming data, and you can register callbacks for notifications or incoming requests when acting as a server. It can be used to query, listen for updates, and modify database contents, but it does not perform the schema and integrity validations that the official OVS CLI tools do, so the author recommends using those tools when you need enforced validation. This is the initial release exposing the RFC 7047 feature set through a straightforward callback-driven API.

Zuzu is a tiny convenience wrapper for running ZuzuScript from Perl, providing two functions, zuzu_eval and zuzu_evalfile, that parse and evaluate a ZuzuScript string or a UTF-8 script file and return the result of that evaluation. You can pass runtime options such as module deny lists and library search paths to control what the evaluated script can load and where to find modules, so it is handy for embedding quick scripts, testing snippets, or driving Zuzu-powered logic from a Perl program. The module focuses on one-shot parse-and-run use cases and keeps the interface minimal so you can integrate ZuzuScript execution into existing Perl tooling with very little boilerplate.

Check::Term is a tiny utility for test suites and scripts that need to know whether the current terminal supports particular terminfo string capabilities. It wraps Term::Terminfo and exports a single check_term_capabilities function plus an $ERROR_MESSAGE variable so you can ask, for example, check_term_capabilities('parm_ich') and get a simple true/false result while $ERROR_MESSAGE contains a human readable reason when a capability is missing. The module is aimed at avoiding duplicated terminal checks across distributions and is handy for conditionally skipping tests or falling back to alternative behavior when terminal features are absent. It is lightweight, depends on Term::Terminfo, and this 0.01 release is the initial version.

Router::Ragel is a high-performance Perl URL router that compiles your route patterns into a single Ragel-generated DFA and emits the matcher as C code via Inline::C, so matching is a fixed-cost state-machine walk rather than a per-route regex scan. You add routes with readable patterns like "/users/:id<int>" and then call compile before matching to produce a shared library that the process dlopen's, and you can call Router::Ragel::match($router, $path) for the lowest overhead. The router supports static segments, named placeholders, typed placeholders and mixed literal-plus-placeholder segments, and returns captures positionally in pattern order. It shines when you have many routes or very high request rates and is deliberately tuned for speed compared with regex or trie routers. Be aware that patterns and paths are treated as byte strings and matches are exact, patterns must start with "/", a ":" always begins a placeholder so literal colons are not supported, adding routes after compile invalidates the compiled matcher until you re-run compile, and when multiple routes match the one added last wins. For pre-forked servers compile once in the parent or populate Inline::C's cache at build time to avoid concurrent compilation at startup.

Markdown::Simple is a compact, fast Perl XS module for converting Markdown to HTML with a GitHub Flavored Markdown default and easy switches to strict CommonMark or individual feature toggles. You can call the simple procedural function to convert a single document or create a persistent Markdown::Simple object to reuse the parser arena when rendering many documents and avoid repeated malloc/free overhead. The module supports common GFM features such as tables, strikethrough, task lists and autolinks, and offers options like hard line breaks, unsafe URL allowance, and strict UTF‑8 checking, plus per-syntax toggles to disable headers, lists, code blocks, links, images and more so constructs can be treated as literal text. A strip_markdown helper removes formatting while leaving readable list and table markers. If you need a fast, configurable Markdown-to-HTML renderer from Perl that defaults to GFM but can be tightened to CommonMark, this module is a good fit.

App::karr is the core of the karr command line tool, providing a Git-native kanban system that stores board configuration, tasks, and logs in refs under refs/karr/* so your repository stays the source of truth and you avoid adding a persistent board tree or file-level merge conflicts. Each karr command materializes a temporary board view, lets you edit task cards written as Markdown with YAML frontmatter, and then serializes changes back into Git refs for sharing and pushing. The distribution includes the karr CLI, Docker images for predictable runtimes, and lower-level Perl modules like App::karr::Git, App::karr::BoardStore, and App::karr::Task for programmatic access and automation. It is a good fit for projects that want to keep task state inside Git and for teams or tools that need scripted control of kanban data. Running karr with no subcommand shows a board summary by default and the README and command modules document day-to-day usage.

App::DuplicateFilesUtils provides small command-line tools to find and manage duplicate files by content. It includes show-duplicate-files, which prints grouped duplicates so you can inspect and decide what to do, and move-duplicate-files-to, which moves all but one copy of each duplicate set into a directory you specify and supports authoritative directories and a dry-run mode for safe testing. There is also a planned tool to replace duplicates with symlinks but that operation is currently unimplemented. The commands are designed to be script-friendly and return structured status information for automation. If you need finer control you can use the underlying uniq-files and dupe-files tools directly. The package was recently updated to use File::FindUniq for duplicate discovery, modernizing its backend.

Geo::Coder::List is a glue module that lets you treat many geocoding services as a single, predictable API: you can push multiple provider objects into an ordered chain, route queries to particular backends with regexes and per-backend limits, and get normalized results that always include canonical latitude and longitude fields so they work with modules like HTML::GoogleMaps::V3 or HTML::OSM. It keeps a fast in-memory L1 cache and can use an optional L2 cache via CHI or a plain hash, supports forward geocoding and reverse lookups, provides a way to set a shared LWP::UserAgent across providers, and records per-request logs that you can inspect or flush. Version 0.37 adds configurable cache TTLs, Readonly constants, logging for reverse_geocode, and smarter ua() handling that clones the supplied agent per geocoder and preserves each provider's User-Agent string so services such as OSM Nominatim accept requests. If you need a single, extensible façade for multiple geocoders with caching and routing, this module is a good fit. Note that reverse_geocode currently does not accept Geo::Location::Point objects and Geo::GeoNames multi-candidate results are handled only by taking the first candidate.

Developer::Dashboard is a purpose-built local workspace that gives developers a single, consistent home for bookmarks, notes, helpers, repeatable tasks, and status probes across your shell, prompt and a small local web UI. It stitches together a browser interface (default on port 7890), a thin "dashboard" CLI, prompt-status fragments, file and path aliases, open-file helpers, a small set of structured-data query tools, and Docker Compose helpers so project-specific shortcuts and health checks live behind one entrypoint instead of scattered scripts and tabs. The runtime is layered so a project-local ./.developer-dashboard can override home defaults under ~/.developer-dashboard while still inheriting shared fallbacks, and background "collectors" prepare cached state that drives lightweight prompt indicators and the web status strip. The system supports saved bookmark-style pages with Template Toolkit rendering and sandboxed code blocks, a plugin-like "skills" system for extending commands and pages, and per-command hook directories for custom workflows. Recent releases added layered machine-auth for selected saved /ajax routes and a built-in "dashboard api" command to manage API keys with SHA-256 secrets, plus ongoing hardening and helper-staging fixes in the 4.x line. It is implemented in Perl but designed to work across polyglot projects, so it is a good fit if you want a local, scriptable developer home that centralizes navigation, checks, and repeatable ops.

Tstregex is a small Perl library and command line tool that helps you debug regular expressions by finding the longest partial match and pointing to the exact token where the pattern fails. You initialize a regex context, feed strings to it, and the API will tell you whether a full match occurred, return the matching portion and its length, and give the failing token or cleaned subpattern so you can see what went wrong. The CLI can also display an enriched diagnostic view that highlights the rejected part of the string, aligns a pointer under the offending token in the regex, and reports execution time to help detect pathological backtracking. Internally it decomposes the regex into subpatterns and tests them from longest to shortest to identify the failure point, making it useful for debugging complex patterns, teaching regex behavior, and spotting potential ReDoS problems.

Mojolicious is a modern, real-time web framework for Perl that simplifies building web applications and APIs with a clean, Perl-friendly API and sensible defaults. It gives you routing and controller patterns, Perl-ish templates, content negotiation, session and cookie management, form validation, a built-in testing framework and static file serving, plus a full HTTP user agent for making requests from your app. The framework is highly extensible with plugins, helpers, hooks and commands, includes its own lightweight server for development and deployment and has comprehensive guides to get you started quickly. It also provides features important for real-time apps and Unicode-aware handling out of the box. One thing to note is the default secret used for signed cookies is insecure by default so you should set your own passphrases in production.

HTTP::XSHeaders is a fast C-based replacement for HTTP::Headers and HTTP::Headers::Fast that transparently accelerates header handling in Perl programs by providing a mostly compatible XS implementation. You enable it simply by loading the module and existing code or dependencies that use HTTP::Headers or HTTP::Headers::Fast keep working while gaining much better performance. The module is designed to be lean and thread-safe as of version 0.400000 and normalizes header names to standard casing while always converting underscores to hyphens. It also simplifies the as_string output formatting, does not support literal leading-colon names or the old TRANSLATE_UNDERSCORE behavior, and loads Storable while performing cloning at the C level. Distributed benchmarks show significant speed improvements for common operations. This is an alpha release, so try it with caution and report any issues.

psed is a Perl reimplementation of the classic stream editor sed that reads input files or standard input and applies sed-style edit scripts to transform text line by line. It supports the usual sed features such as address ranges, hold space operations, substitution and transliteration commands, labels and branching, and POSIX basic regular expressions, and you can supply scripts via -e, -f or as a single argument while -n and -a control automatic printing and delayed file-opening. Invoked as s2p it will translate a sed script into an equivalent Perl program, making it useful both for automated search-and-replace tasks and for migrating sed scripts to Perl. The implementation is broadly POSIX-compatible and follows OpenBSD behavior with a few known deviations such as Perl-style reuse of empty regular expressions, the l command showing ESC as \e and VT in octal, trailing spaces being truncated from labels, and lack of collating-element support. Recent updates fixed \< and \> word-boundary matching at line boundaries and removed a test dependency, and an earlier release added support for separating commands with semicolons.

DBI is the standard, database‑agnostic interface for Perl that gives your scripts a consistent way to connect to databases, prepare queries, bind parameters, execute statements, fetch results, and manage transactions without tying your code to a particular database engine. It is an API layer only, so actual work is done by driver modules (DBD::*) but DBI provides the common methods and conveniences you expect such as placeholders, prepared statements, select/do wrappers, bulk execution, quoted identifiers, tracing and profiling, error handling modes (RaiseError/PrintError), callbacks and cached connections. If you need portable, testable database access from Perl — from quick one‑off queries to robust transactional applications — DBI is the right foundation and most drivers on CPAN plug into it. This is a mature, actively maintained module and recent releases include security and robustness fixes, including patches for possible stack and buffer overflow issues and improved driver compatibility and tracing, so upgrading to the latest release is recommended.

WWW::Vonage::API is a lightweight Perl client that simplifies calling the Vonage (formerly Nexmo) REST APIs by wrapping common HTTP verbs and handling URL construction, JSON encoding and basic authentication for you. You create an instance with your API key and secret, set optional defaults like API domain, version and region, then call methods like GET, POST, PATCH, PUT or DELETE with a resource path and a payload to send SMS, query reports, manage numbers, check balances and more. Each call returns a simple hashref with the raw content, HTTP status code and status message so you can inspect or parse the JSON response as needed. Note that the module currently implements only Basic Authentication so features that require JWT are not supported. Recent changes add a DEBUG option for diagnostic output and fix a bug that previously lowercased request paths so case sensitive resource names and IDs are preserved.