CPANscan

Date::Manip is a mature, full-featured Perl toolkit for working with dates and times that makes parsing, formatting, comparing, arithmetic, recurrences, holidays and timezone conversion simple and concise. It accepts a wide variety of human and international date formats, can compute intervals or add durations, list recurring events or holidays, and exposes a recommended object-oriented interface that lets you do most common date/time tasks in just a line or two. The distribution includes language files for international parsing, timezone data and utilities for business-day calculations so you can handle real-world calendar needs across locales. Recently the series received routine timezone data updates and a small packaging cleanup in the 7.00-area releases while preserving the established APIs.

Alien::curlimpersonate builds libcurl-impersonate from source and exposes its compiler and linker flags so Perl XS modules can link against a curl that reproduces real browser TLS and HTTP/2 fingerprints rather than stock libcurl. It is a source-only Alien that compiles a curl with a bundled BoringSSL and related libraries at install time, so expect a multi-minute build and a number of build prerequisites such as git, CMake 3.20+, Ninja, Go, patch, curl and a C/C++ toolchain. The distribution deliberately pins the curl-impersonate version to ensure reproducible impersonation targets, and the current release builds upstream curl-impersonate v2.2.2. Note that the provided libs string does not bake in an rpath, so consumers should add an rpath based on dynamic_libs when linking to avoid runtime loader errors.

PAGI::Server is a Perl reference implementation of a PAGI-compliant HTTP server that lets you run HTTP/1.1 applications and also supports WebSocket and Server-Sent Events, with experimental HTTP/2 support via nghttp2. It is designed as the canonical, spec-focused server with a clear API for binding to TCP ports or Unix domain sockets, optional TLS support, multi-listener and pre-fork worker modes, systemd socket activation, and hot-restart tooling for zero-downtime deploys. The server includes production-friendly features such as access log formatting, connection and request limits, backpressure controls, file streaming optimized for large files, and a recommended deployment pattern behind a reverse proxy for TLS and static assets. It uses IO::Async for its event loop and integrates with Future::IO when configured correctly, and several advanced capabilities are marked experimental or optional. PAGI::Server does not support Windows and prioritizes correctness and clarity over micro-optimizations while still delivering competitive performance for real workloads.

Device::Serial::SLuRM is a Perl module that gives you an asynchronous, Future::IO-based way to speak the SLuRM protocol over a serial port, a supplied filehandle, or via UDP-wrapped MSLuRM. It handles reliable framing, CRC checking, NOTIFY messages and REQUEST/RESPONSE transactions with automatic retransmit and configurable timeouts so your application can tolerate noisy or lossy byte links. You can start a receiver run loop to get incoming NOTIFYs, send NOTIFYs, and issue requests that await responses, and the module will auto-reset the link when needed. It exposes options for device path, baud rate, raw fh or host/port, and retransmit tuning, and it will publish metrics through Metrics::Any if available. The module does not currently accept incoming REQUESTs from peers but can act as a controller for multi-drop buses via a subclass.

PAGI (Perl Asynchronous Gateway Interface) is a modern specification for writing async Perl web applications that can handle long-lived connections like WebSocket and Server-Sent Events, designed as a successor to PSGI. Instead of a single synchronous request/response coderef, a PAGI app is an async sub that receives a scope describing the connection and two async callbacks, receive and send, which exchange message events and return Futures so backpressure and multiple incoming or outgoing events are handled naturally. This distribution provides the stable specification and documentation while the reference server and convenience toolkit live in separate PAGI::Server and PAGI::Tools packages that you can install to run and test apps. The spec is stable but the reference server and tools are currently beta, so you should rely on the PAGI interface and expect the server and toolkit APIs to evolve. If you want to build or migrate Perl web services that need true asynchronous, message-oriented behavior, PAGI is the recommended foundation and includes tutorials, a migration guide from PSGI, and example apps.

Developer::Dashboard is a local developer “home” that consolidates bookmarks, notes, helper commands, path and file aliases, quick data inspectors for JSON/YAML/TOML/properties, Docker Compose helpers, a small web UI and a prompt-status layer so you can keep project shortcuts, health checks and workflows behind one consistent entry point instead of scattered scripts and tabs. It uses a layered runtime that lets a project-local ./.developer-dashboard override a shared ~/.developer-dashboard so teams can add repo-specific pages, collectors and CLI hooks without losing common defaults, and it runs background collectors to prepare state that feeds cheap prompt indicators and the browser status strip. The toolchain also supports opening files by module or class name, lightweight template-backed pages with executable code blocks, a skills plugin system, tmux-aware workspace integration and machine-auth API keys for safe automated access. Security and hygiene are built in with owner-only runtime file permissions by default, helper-login gating for non-local requests and guarded transient token behavior. Recent releases further hardened process cleanup and collector supervision and fixed subtle subprocess exit-state bugs in 4.29 so child commands no longer leak their exit status into unrelated code. Use Developer::Dashboard if you want a unified, extensible local dashboard to organize daily development tasks across polyglot projects.

Clownfish::CFC is a Perl interface to the Clownfish compiler that lets Perl code drive the process of compiling and working with Clownfish definitions. The module is an alpha release and its public API has been intentionally cloaked, so the interfaces are unstable and intended for experimental or developmental use rather than production deployment. If you want to explore or prototype with Clownfish from Perl this module gives you a starting point, and it is distributed under the Apache License 2.0.

Logic::Relational is a pure-Perl relational logic engine that brings Prolog-style facts, rules, logical variables and depth-first backtracking into Perl programs via a convenient hybrid syntax layer. You declare logic databases where relations describe truths rather than fixed inputs and outputs, then run queries that yield iterators of solution bindings produced by unification and backtracking. The module handles structured terms, list decomposition, negation-as-failure, inline disjunction, generators and guards, and includes a library of common relations such as member, append and permutation. It also includes basic CLP(FD) support for finite-domain constraint solving with domain declarations, arithmetic constraints and labeling so you can solve combinatorial problems declaratively. Runtime features include program objects for asserting and retracting facts, transactional updates, expiring facts with TTL and snapshot save/load, plus tracing and change notifications to aid debugging. This is the initial 0.01 release.

Data::HashMap::Shared is a high-performance, Linux-only Perl module that implements file-backed, multiprocess shared-memory hash maps with optional LRU eviction and per-key TTL, making it ideal for cross-process caches and counters. It stores maps in mmap'd files or memfd handles so multiple processes can open and modify the same table, and it provides lock-free fast-path reads, futex-backed writers, atomic integer ops like incr/decr/max/min, and a compact arena for string storage, plus a keyword API for low-overhead calls. There are ten typed variants for integer and string key/value combinations and a sharded constructor to scale writes in parallel, and it supports freezing a file to create a sealed read-only snapshot that can be safely distributed. Be aware that integer variants use fixed-width two's-complement storage so out-of-range integers are silently truncated, TTLs are measured with a monotonic clock so expiries do not shorten across reboots, and cross-container PID namespaces are not supported for stale-lock recovery. Recent maintenance in 0.18 tightened crash safety and fixed cursor and reserve edge cases so the map is more robust against writers killed mid-operation and against misuse after destruction. If you need a very fast, concurrent shared hash with built-in eviction, TTLs, and durability options and you are running 64-bit Perl on Linux, this module is a strong fit.

Version::Semantic is a lightweight Perl module for parsing, validating, and manipulating semantic version strings in your scripts and tools. It converts semver text into version objects you can inspect and change, offers methods such as parse() and increment(), exposes a semver_re() class method for pattern matching, and provides attributes like prefix and an is_core() predicate to help identify Perl core versions. Recent releases made Version::Core a superclass and added the semver_re() helper, and note that since v2.0.0 parse() will return undef instead of dying unless you explicitly fatalize it. Use this module when you need reliable semver handling, version comparison, or programmatic version bumps in Perl projects.

App::CPANModuleSite is a small tool that builds a static website for a Perl module by turning module Pod into HTML, applying Template Toolkit page templates, and copying any non-template assets into an output tree. It is normally used via the bundled mksite command rather than by calling the class directly, and is handy if you want a simple, consistent documentation site for a CPAN distribution without handcrafting pages. Recent updates focused on polish and usability, including making the site layout responsive so the sidebar hides on smaller screens and a series of infrastructure improvements to the project.

Net::DNS is a mature, full‑featured Perl library that gives you low‑level DNS client and server building blocks so you can make and parse queries, perform zone transfers and craft dynamic updates far beyond the simple gethostbyname/gethostbyaddr facilities. It provides resolver objects plus packet, header, question and resource record classes, helper shortcuts for common lookups like rr() and mx(), and utilities for building update packets, managing SOA serials and sorting RR arrays. The distribution supports modern DNS features such as EDNS, TSIG, DNSSEC hooks, IPv6, IDN and newer RR types like SVCB/HTTPS, and includes zonefile parsing and nameserver components for testing or authoritative behavior. Net::DNS is actively maintained by NLnet Labs and recent releases resync IANA parameters, add EDNS MQTYPE‑QUERY support and address several security issues including fixes for compression‑chain and EDNS extended error vulnerabilities. Note that the module prioritizes completeness and correctness over raw throughput so it can be slower than minimal DNS clients, making it a good choice when you need full DNS control from Perl.

Sys::Async::Virt is an asynchronous Perl client for the libvirt remote protocol that lets you control and query hypervisors from Perl code using Futures and async/await. It wraps virtually the same libvirt functionality in an object oriented API so operations like connecting, listing domains, creating networks or managing storage pools return Futures you can await and event subscriptions yield callback futures for domain, network and device events. The module supports multiple transports including process, SSH and TCP, offers SASL and keepalive handling, streams for volume upload/download and a large set of libvirt constants so you can use up‑to‑date protocol features without diving into the C API. It is generated against libvirt v12.7.0 and aims to be compatible with newer servers while older servers may lack some entry points and a few features remain unimplemented, and the distribution is currently marked experimental so the public API may still evolve. The most recent release updated the binding to libvirt v12.7.0 and added a number of new constants related to I/O thread poll weight and guest device information.

ForgeOps::Tracker is a lightweight Perl client for sending application errors and exceptions to a self-hosted ForgeOps error-tracking server. You initialize it with a DSN and environment and then call report when an exception occurs, which makes it easy to centralize error monitoring from Perl code. The module includes guidance for integrating with PSGI, Plack and Dancer2 and documents delivery behavior and PII scrubbing in the SDK README, so it is useful for production services that need centralized reporting while controlling sensitive data. Use this module if you operate a self-hosted ForgeOps instance and want a simple programmatic way to capture and send error events from your Perl applications.

Protocol::Sys::Virt implements the libvirt RPC protocol in Perl, providing the XDR (de)serializers, transport and stream handling, URI and unix-socket helpers, and ancillary routines you need to build libvirt-aware clients and low-level tools. Its main purpose is to enable truly asynchronous, non-blocking interaction with libvirt from Perl without relying on Perl threads, so it fits event-loop and Future/async-await style code where Sys::Virt’s synchronous API would block. This distribution is a protocol-level toolkit rather than a high-level convenience wrapper, so it is most relevant if you want to implement custom transports, integrate libvirt into async applications, or build diagnostic and protocol tooling; building a full libvirt server is supported but generally unnecessary. The module follows libvirt’s protocol releases and is currently updated to libvirt tag v12.7.0, so it includes the protocol additions and event constants up to that release. Documentation is still a work in progress, but the changelog shows ongoing fixes and feature additions such as stream support, URI parsing, typed-parameter helpers, and keepalive improvements.

Config::INI::RefVars is an enhanced INI parser for Perl that turns configuration files into plain Perl data while adding powerful features like variable references, built-in and user-defined function calls, include directives, line continuations and several assignment operators for flexible value composition. It produces a hash-of-hashes via the variables method, supports cross-section references, access to environment and Config entries, and a special tocopy section or optional global mode for shared defaults, and you can register custom built-in functions when constructing the parser. All references and function calls are resolved during parsing so the result contains only simple scalars, and parsing errors such as recursive references or syntax problems throw exceptions and may leave the object unusable. The module requires Perl v5.10.1 or newer. Recent releases added a registerable builtins mechanism and extra built-in helpers such as catpath and the newest maintenance release corrected license metadata.

App::Envdoctor is a small command-line tool that checks consistency between environment variables your Perl code actually uses and the variables declared in your .env files. It scans source for $ENV{VAR} references and reports variables that are used but not defined as errors and variables that are defined but never referenced as warnings, which helps you catch missing configuration and clean up stale entries. The tool runs locally only, never uploads data and never prints variable values, so it is safe to run in projects with sensitive settings. Use it when you want a quick, automated way to validate and tidy environment configuration for Perl projects.

Robots::Validate is a utility for web applications that checks whether an HTTP user-agent string that claims to be a known web robot actually comes from the robot's documented IP space. It uses a rules file of agent names, domain suffixes and network blocks to either match an IP directly or perform reverse DNS plus forward-confirmation to verify a hostname belongs to the robot, and it returns a clear success, failure or unknown result so you can treat bots differently in logging, rate limiting or content negotiation. The module now matches multiple agent substrings efficiently with the Aho-Corasick algorithm, supports a configurable TOML rules file, optional caching of results and adjustable validation modes to control how overlapping agent names are handled. The recent 0.4.0 release is a complete rewrite that raises the minimum Perl version, adds caching and match-mode control and introduces limits on forward DNS lookups to mitigate abuse. Be aware that the rule set is not exhaustive, cloud or decentralized crawlers may not be verifiable and DNS-based checks can be unreliable, so you should follow the module's guidance when configuring cache expiry and domain suffix rules.

Text::Table::Read::RelationOn::Tiny parses simple text "cross" tables that represent a binary relation on a set and turns them into a programmatic incidence matrix plus a list of element names and their numeric ids. It reads ASCII tables where cells are either a marker (default "X") or empty, accepts input from files, strings, array refs or filehandles, and returns a hash-of-hashes incidence matrix, an element array and an id map in one call. The module supports preset base sets and equivalent-element groups, optional subset tables, a pedantic mode to enforce table formatting, options to use external data without copying, and helpers to return named matrices or a blessed matrix object with a related() method. If you work in Perl and need to convert human-readable relation tables into adjacency/incidence structures for graph, relation or matrix processing, this is a compact, well documented tool that requires Perl v5.10.1 or later; the most recent updates mostly tidy documentation and security metadata.

Photonic is a Perl toolkit for modeling and computing the optical response of metamaterials and photonic structures. It gives you modular building blocks to describe geometry from characteristic functions, microscopic dielectric maps, or 2D images and to compute dielectric tensors, longitudinal responses, Green tensors, microscopic fields, Haydock coefficients, and second harmonic susceptibilities. The distribution supports binary and multi‑phase systems and offers both non‑retarded (longitudinal) and wave‑equation based formalisms, including a spinor representation for complex materials, plus utility and role modules to factor common behavior. It is aimed at researchers and engineers who need scriptable, reusable tools to extract macroscopic and microscopic optical properties and is released under GPL/Artistic licensing.

MIDI::RtMidi::Util is a compact helper module for working with real-time MIDI from Perl, providing simple utilities around MIDI::RtMidi::FFI::Device. It lets you open an output by part of its name with out_port, stop and close a RtMidiOut with halt, and query available inputs and outputs with input_ports and output_ports. Recent changes removed an automatic program exit from halt and added the input_ports and output_ports functions to make port discovery and graceful shutdowns easier.

Crypt::Age is a pure-Perl implementation of the age file-encryption format that lets Perl programs generate X25519 keypairs, encrypt and decrypt data or files, and interoperate with the standard age and rage command-line tools. It uses modern primitives provided by CryptX (X25519 for key agreement, ChaCha20-Poly1305 for authenticated encryption and HKDF-SHA256 for key derivation) and offers both simple in-memory APIs for small payloads and streaming filehandle APIs that read and write in 64 KiB chunks so memory use stays bounded. The module supports Bech32-encoded age public and secret keys and implements the X25519 recipient type end-to-end, but it does not implement scrypt (passphrase) recipients, SSH recipients, post-quantum/tagged recipient types or ASCII armor. Recent releases tighten spec compliance and safety: header parsing is stricter (now rejects headers with no recipient stanza), parsing and encoding are more exact, and error messages and checks were hardened to avoid accidental leakage of key material and to improve interoperability with age/rage.

Rex::LibSSH is a Rex connection backend that uses Net::LibSSH to run commands and perform file and filesystem operations over plain SSH exec channels instead of SFTP, making it useful for minimal containers, embedded systems, or any host where an SFTP subsystem is not available. You enable it by setting the connection type in your Rexfile and it supports public key authentication with optional strict host key checking for interactive security. Unlike Rex's built-in SSH drivers this module implements stat, ls, upload, download and similar operations by shelling out over SSH, so it works where SFTP would be missing, but it does not route filesystem calls through Rex::Interface::Fs::Sudo and upload/download/read-mode calls keep the entire file in memory on both ends. Recent 0.003 fixes make exec() accept the three-argument signature used by Rex::Commands::Run so environment hashes and shell options are passed through, add input validation to block NUL bytes and unsafe glob metacharacters, and include tests proving operation against sshd builds without an SFTP subsystem.

Net::LibSSH is a Perl XS binding for the libssh C library that gives Perl programs direct SSH capabilities such as opening session channels and running remote commands. You create a session, set host, user, port and other options, connect and authenticate by password, public key or agent, then open Net::LibSSH::Channel objects to exec commands and read their output; an optional SFTP interface is available but returns undef if the remote server does not support SFTP. Because it exposes exec channels rather than a file-transfer API, file operations can be implemented on top of channels so SFTP is not mandatory for automation. Note that the module is not thread safe and does not support fork, and once a session has been connected and then disconnected it cannot be reconnected, so use one connection per process and check error messages via the error method.

Alien::libssh is a small helper module that supplies the libssh C library for other Perl modules so they can compile and link against SSH functionality. It prefers a system-installed libssh discovered via pkg-config and falls back to building a bundled copy from source with CMake so no network access is required at install time. The module exposes standard Alien::Base methods such as cflags and libs so build tools and XS modules can pick up the correct compiler and linker flags. The recent 0.002 update fixes the bundled (share) build so the packaged tarball is actually used, builds libssh statically and appends -lcrypto and -lz so XS consumers do not require a runtime libssh.so, and makes sure pkg-config is used to gather flags on both install paths while forcing the share build during author release tests to exercise the offline fallback.

AmberDB is a high-performance flat-file NoSQL engine for Perl that sits on top of Berkeley DB (DB_File) and gives you schema-driven records, precomputed inverted indexes, columnar facet indexes, and full ACID transactions with undo journaling and strict two-phase locking for safe multi-table updates. You can use it like a document store with nested repeating blocks or in a lightweight simple mode as an ultra-fast schemaless key-value store that supports RAM-disk caching, full-text search with multilingual normalization, slug maps, and a rich set of helpers for inserts, updates, deletes, reads, filtering and pagination. Schemas live on disk or can be changed at runtime, indexes are built automatically from schema definitions, and the API exposes both high-level operations (field_fetch, search_table, read_all) and low-level DB_File access for bulk or recovery tasks. Recent releases hardened ID validation and simple-mode key sanitization, standardized slug handling and .slg files, and strengthened concurrency and cross-platform flocking; note that a previous release introduced an important migration: your schema directory must be named schema/ rather than scheme/.

Perl::Critic::Policy::ProhibitPipeOpen is a linting rule for Perl that spots and forbids using open with pipe modes to start external processes, closing a loophole left by other policies that already flag system, exec, qx and backticks. It makes sure pipe opens like open(my $fh, '-|', ...) or the old "ls |" spelling are treated the same as other shell-outs so every use of spawning a command must be made explicit with a "## no critic" and an accompanying justification. Ordinary file opens remain allowed and normal. The policy runs at the highest severity and is grouped under security and performance, and note that it only recognizes a pipe mode when that mode is a literal in the source code.

Crypt::OpenSSL3 is a modern Perl wrapper for the OpenSSL cryptography library that gives Perl programs access to SSL/TLS connections, asymmetric keys, symmetric ciphers, message digests, MACs, KDFs and X.509 certificate handling via focused submodules such as Crypt::OpenSSL3::SSL, ::PKey, ::Cipher, ::MD, ::MAC, ::KDF and ::X509. The top-level module itself provides error handling and build-time introspection so you can query OpenSSL version and configuration from Perl. The distribution is actively maintained and keeps pace with OpenSSL changes, adding features like HPKE, PKCS7, ASN1 helpers, encoding/decoding, X509 store/context improvements and password-callback support for private keys, and it is available under the Apache 2.0 license.

Punk::Authorisation provides row-level authorization for Punk web applications by letting you define simple, application-owned rules that answer whether the current user may act on a specific database row. It supplies a plugin that installs a rule DSL and controller helpers so you can write checks like $c->may('doc.edit', $doc) and get clear outcomes, with refusals translated into the correct HTTP responses to avoid leaking the existence of other users' rows. The distribution also offers an optional grants table (Punk::Model::Grant) when you need delegated permissions and integrates with Punk's auth configuration for role ladders. This initial release extracts the logic from Punk::DIY and includes a demo application that exercises every rule against every row.

Tomba::Finder is the official Perl client for the Tomba.io Email Finder API that makes it easy to discover and verify contact data from Perl code. It exposes one-line methods for common tasks like searching a domain for known emails, generating the most likely address from a name and domain, verifying deliverability, enriching a profile from an email, finding author or LinkedIn emails, locating phone numbers, searching companies, managing leads and API keys, and running bulk operations. The module acts as a simple facade mapping API endpoints to Perl methods while also offering standalone submodules if you need more granular control. If you are building contact discovery, lead enrichment, or data verification into Perl scripts or apps, this module provides a ready-made, documented interface to the Tomba service and includes examples and links to full API docs.