CPANscan

Time::Str is a Perl library that parses and formats date and time strings across a wide range of standard formats and real-world variants, letting you convert text timestamps to Unix epoch seconds or to parsed components and render epoch values back to RFC3339, RFC2822, HTTP, SQL, ASN.1, iCal and many other common formats. Its three main routines are str2time to produce a numeric timestamp with optional fractional seconds, str2date to return validated components (year, month, day, hour, minute, second, nanosecond and timezone fields) without requiring a timezone, and time2str to format epochs with configurable precision or exact nanosecond control. The parser accepts ISO 8601/RFC3339 and a permissive "DateTime" grammar, supports timezone offsets and DST-aware timezone objects, and can resolve ambiguous abbreviations when you supply a timezone_map, while precision rules ensure predictable truncation when parsing and rounding when formatting. Time::Str ships with an optional XS backend for speed and a Pure‑Perl fallback, interoperates cleanly with DateTime, Time::Moment and Time::HiRes, and reports errors by croak so calling code can trap parse and usage failures. Note the documented limitations: month and day names are English only, ISO week and ordinal dates are not supported, years are limited to 0001–9999, and timezone abbreviations are captured but not auto-resolved unless you provide mappings.

BarefootJS is a server-side runtime for templates compiled from JSX/TSX into a marked template plus client JavaScript. It is engine- and framework-agnostic and delegates tasks that depend on the rendering environment, such as JSON marshalling, raw-string marking, JSX children handling, and named-template rendering, to pluggable backends. Shipping backends include BarefootJS::Backend::Xslate for Text::Xslate and BarefootJS::Backend::Mojo for Mojolicious, and the core itself only uses Perl core modules so you only pull in a template engine or web framework when you install a backend. Use this module when you want a single Perl runtime to drive JSX/TSX-style templates across different web frameworks and template engines. The distribution is newly released with the initial engine-agnostic runtime and backend-driven design.

DBIx::Class::Schema::GraphQL automatically generates a ready-to-run GraphQL::Schema from an existing DBIx::Class schema so you can expose your database as GraphQL without hand-crafting types or resolvers. It maps table columns to standard GraphQL scalars, exposes relationships as fields, produces singular lookups and plural "allX" queries with filtering, ordering and both offset and cursor pagination, and creates create/update/delete mutations for each source while handling composite primary keys. The module returns a GraphQL::Schema you can pass to GraphQL::Execution and the original DBIC schema as context, making integration straightforward. Bear in mind a few deliberate limitations: related fields are unfiltered, mutations accept only scalar inputs and update is a full update, cursors work only with primary-key ordering, custom SQL types become plain strings and there are no subscriptions, and you should include a scalar field (for example total) alongside nodes in plural queries to avoid a resolver quirk. This is the initial v0.0.1 release aimed at quickly exposing DBIx::Class models over GraphQL for typical CRUD workloads.

PSGI::Handy is a tiny, dependency-free application layer for PSGI that bundles a router, request and response objects and a per-request context into a single-file framework. You build an app by injecting a template renderer and optionally a database handle, register routes using readable patterns like :name and a trailing * splat, and call to_app to get a standard PSGI application that any PSGI server can run. Route handlers receive a Context object that exposes request params, a stash, DB access, rendering helpers and response builders, and may return a Response object, a PSGI array ref or a plain string treated as HTML. The router matches paths exactly and supports method-based 405 handling, query and urlencoded form parsing is provided but multipart uploads and streaming responses are not supported, and HEAD requests are served by the GET route with the body removed. Because it requires only core Perl, PSGI::Handy is easy to test and ideal for small services, prototypes or when you want a minimal, readable PSGI app. This is the initial 0.01 release.

Cpanel::JSON::XS is a high-performance, C-backed JSON encoder/decoder for Perl that prioritizes correctness and Unicode handling while offering many practical options for real-world use. It provides a simple functional API plus a configurable object interface to produce UTF-8, ASCII or latin1 output, pretty-printing, canonical key sorting, relaxed parsing modes, object serialization hooks, incremental stream parsing, and fine-grained controls for booleans and bignums. This cPanel-maintained fork adds public bug tracking, ithreads safety and numerous robustness and security fixes while remaining fully compatible with common Perl JSON front-ends such as JSON::MaybeXS so it will be picked automatically where available. Note that recent releases changed the default to accept non-reference top-level JSON values for compatibility with other JSON modules, which can be reverted by calling allow_nonref(0) if you need the older, stricter behavior. If you need fast, standards-conscious JSON handling in Perl and care about correct Unicode and edge-case behavior, Cpanel::JSON::XS is an excellent choice.

Protocol::HTTP2 is a Perl implementation of the HTTP/2 protocol (RFC 7540) that provides stateful encoders and decoders for HTTP/2 frames so you can build your own client, server or intermediary on top of any event loop and plain or TLS sockets. It includes helper classes for clients and servers, a Connection module that handles protocol state, an HPACK implementation for header compression, protocol constants and a trace/debug facility, and comes with examples showing ALPN/NPN and HTTP/1.1 Upgrade usage; you can also query the protocol identifier strings for TLS and plain connections. The project is marked beta by the author and some features are incomplete or not implemented, most notably parts of flow control and priority handling, the CONNECT method and a few frame encoders, so it may not be ready for all production workloads. A recent and important update fixed a remote denial-of-service "HTTP/2 Bomb" vulnerability (CVE-2026-10725), so users should upgrade to the latest release for that security fix.

DateTime::Format::RelativeTime is a Perl implementation of the web Intl.RelativeTimeFormat API that produces localized, human friendly phrases like "in 3 months", "yesterday" or "1 day ago". It uses Unicode CLDR data via Locale::Unicode::Data and Locale::Intl to support many locales and numbering systems, accepts numeric offsets or DateTime/DateTime::Lite objects to compute the largest unit difference, and exposes options for locale, style (long, short, narrow) and numeric handling (always or auto) so you can get either strict numeric output or idiomatic words such as "tomorrow". You can obtain either a simple formatted string with format or a structured array of parts with formatToParts for custom rendering. The module aims to match browser behavior, so some locale and numbering fallbacks mirror web engines, and you should create and reuse formatter objects because initialization performs CLDR lookups. It limits displayed numeric precision to 15 significant digits and requires Perl 5.10.1 or later.

CGI::ACL is a compact Perl helper for CGI scripts that decides whether to allow a client based on IP addresses or CIDR ranges, country codes and whether the client appears to be hosted by a major cloud provider. You configure it by calling methods such as allow_ip, deny_country, allow_country and deny_cloud and then invoke all_denied to get a simple 1 (deny) or 0 (allow) answer; country checks use an optional CGI::Lingua object to resolve the client country. The module defaults to allowing all traffic unless you add rules, supports deny_country('*') to switch to default-deny with an allow list, and performs verified reverse DNS checks to identify cloud hosts which take precedence over explicit allow_ip entries. It handles IPv4 and IPv6, supports CIDR caching for performance, can be configured at runtime with Object::Configure and uses a guarded synchronous DNS lookup with a timeout to avoid indefinite blocking. The recent 0.08 release fixed multiple correctness and security issues including a REMOTE_ADDR handling bug that could lead to loopback being treated as the client, improved IPv6 cloud detection, added DNS timeouts and CIDR caching, and generally hardened error handling; be aware that IP based controls can still be bypassed by proxies or VPNs.

App::XWindowManagerUtils is a small Perl toolkit for working with the X Window Manager, aimed at scripts and automation that need to discover or inspect open windows. Its main offering is the exportable list_xwm_windows function which accepts options such as a boolean detail flag and a query array and returns a predictable, enveloped result made of an HTTP-like numeric status code, a human reason string, an optional payload with the window data, and optional metadata for extra context. The structured return makes it easy to detect errors and programmatically consume results from Perl on X11 systems. The distribution is lightweight and early stage (version 0.001) and the source and CPAN page are available for more details or contributions.

DateTime::Format::Intl brings the browser-style Intl.DateTimeFormat API to Perl so you can produce locale-aware date and time strings from DateTime objects using real CLDR data. It accepts BCP 47 locale tags, time zones, numbering systems and the same component or style options you know from the web API, and offers handy methods for formatting single dates, date ranges, and for returning the formatted parts for custom rendering. The module mirrors common Intl behavior including dayPeriod and timeZoneName options, exposes resolvedOptions, pattern and skeleton information, and provides a few extras such as greatest_diff for range formatting. It is dependency-heavy and requires DateTime::Format::Unicode, DateTime::Locale::FromCLDR, Locale::Intl and Locale::Unicode::Data and Perl 5.10.1 or newer, so object construction can be expensive and you should create and reuse formatter objects rather than rebuilding them for each date. Note that the implementation only supports the Gregorian calendar and some constructor matcher flags are effectively no-ops because it aims to match browser behavior. If you need accurate, CLDR-driven, locale-sensitive formatting in Perl this module gives a close equivalent of the JavaScript Intl.DateTimeFormat API.

DBIx::QuickDB is a developer-focused utility that makes it trivial to spin up temporary database servers for testing and development, supporting PostgreSQL, MySQL variants and SQLite out of the box and optionally DuckDB when available. You can declare named, globally accessible databases at compile-time or create and manage instances on the fly with build_db, and each instance can be autostarted, bootstrapped from a directory, seeded with SQL, cloned, pooled or cleaned up automatically. Configuration is simple and flexible via a spec hash or environment variables such as QDB_TMPDIR and DB_VERBOSE, and you can tune startup and shutdown timeouts via QDB_START_TIMEOUT and QDB_STOP_GRACE for slow CI hosts. The module includes safety features for stopping and cleaning up servers, but its cleanup option will delete directories so you should not point it at any production data. Recent fixes improved robustness against a PID-reuse race that could accidentally shut down the wrong server and added tunable timeouts and other stability enhancements to make it more reliable on slow or idiosyncratic platforms.

Hypersonic is a benchmark-focused Perl micro HTTP server that JIT-compiles C at build time so the hot path runs in native code for very high throughput. Handlers that return static responses are executed once at compile and baked into C string constants while dynamic routes run Perl per request with JIT-compiled request objects, and the core event loop (kqueue/epoll or io_uring where available) is generated as C and compiled via XS::JIT. The framework also supports WebSockets, optional room-based broadcasts, server-sent events and streaming, TLS via OpenSSL, gzip compression via zlib, session cookies, a JIT-compiled async thread pool, and a way to inject custom C helpers or whole route handlers with need_xs_builder. You must have a C toolchain and the XS::JIT ecosystem plus any optional libraries like zlib or OpenSSL, so Hypersonic is best suited to projects that value extreme performance and are comfortable with a compile step and native dependencies. A recent notable change makes compile() derive the JIT module id from an MD5 hash of the generated C source instead of a random number, improving cache stability and reproducible builds.

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.