CPANscan

Music::MelodicDevice::Arpeggiation is a small helper for generating arpeggios for use with MIDI-Perl by turning a group of pitches into an ordered sequence of timed MIDI-Perl note specifications. You create an object and call arp with an array reference of pitches (note names or MIDI numbers) and optional duration, pattern type and repeat count, and it returns lists like ['d24','C4'] that you can feed into MIDI routines. It ships with handy presets including up, down, updown and random, uses a quarter-note duration and a single repeat by default, and lets you register your own pattern coderefs via arp_type to define arbitrary index sequences. The module is useful for algorithmic composition, automated MIDI generation and any workflow where you want simple, programmable arpeggiation without dealing with low-level timing details.

SPVM::Thread is a thin binding to C++ std::thread that lets SPVM programs create and run native threads from a simple object interface. You create a thread with Thread->new by passing a Callback to execute, then use join to wait for it and get_id to obtain the thread identifier, while each Thread holds the task and caller_info for context. Recent releases improved error reporting so exceptions raised in threads include the thread caller stack, which makes debugging easier. Use this module when you need true native concurrency in SPVM and want straightforward control over thread lifetime and identity, keeping in mind it is a low level primitive and you will handle synchronization and shared data yourself.

Alien::Xmake is a thin Perl wrapper around the xmake and xrepo command line tools that helps you find, download, build and install the Xmake build utility and the libraries or tools it manages. It exposes high level methods that mirror xmake actions such as create, configure, build, run, test, install, package, repo, show and watch and it can also fetch compile and link flags for dependencies via pkg_config, which makes it handy for writing Alien::* modules or automating builds from Perl. The module supplies helpers for alienfile recipes and returns paths to executables and package install directories so you can run or bundle tool packages like ninja or python as well as libraries for FFI usage. The recent v0.9.0 release adds Alien::Xrepo and Alien::Xrepo::Base to provide broad integration with many package backends including vcpkg, conan, homebrew, conda, cargo and several system package managers, enables project-local package stores, improves JSON handling and adds convenient confirmation and verbose options for scripted installs. If you need to integrate Xmake-based builds or xrepo-managed packages into Perl distributions or developer tooling this module removes the glue work and gives you a programmatic, cross-platform interface.

Clownfish is a "symbiotic" object system and code generator that helps developers write high-performance language extensions and bindings by pairing a C-based runtime with host-language glue. You write class definitions in Clownfish header files and the CFC compiler produces C headers, initialization code, host-language bindings, and documentation so the same core implementation can be exposed to C, Perl 5, Go, and other hosts. The runtime supplies a compact object model, common data types like strings, arrays and hashes, a Class metaclass, introspection and a documentation generator, and it aims for ABI stability so you can evolve APIs without breaking binary compatibility. Clownfish is already used by the Lucy search engine and is especially useful if you need fast, modular native extensions with support for subclassing and host-language idioms. The project is actively maintained and the recent 0.8.0 release updated its Markdown library and fixed a number of runtime, compiler and Perl-related issues.

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.

Hyperman is a high-performance PSGI server for Perl that pairs a prefork supervisor with a native per-worker event loop so Plack apps can run synchronously or return a Future for true async work. It supports HTTPS with SNI and optional kernel TLS, optional HTTP/2, built-in gzip compression, fast C-side access logging, request-body spill-to-temp-file to bound memory use, accept-time denylists and shared rate limiting across the pool, and a lightweight cross-worker publish/subscribe bus for broadcasts or queue-style groups. Hyperman also exposes a C ABI so other XS modules can install fd watchers, timers and futures without a Perl call on the hot path, provides per-worker startup hooks, graceful zero-downtime restarts and a connection detach facility for protocol upgrades, and integrates with plackup. Recent releases added completion-mode reads for io_uring and made Hyperman::Future implement the Future::AsyncAwait::Awaitable API so await works inside async subs and cancel handlers can be registered.

Punk is a modern, fast MVC web framework for Perl that gives you a compact DSL to declare routes, guards, static mounts, OpenAPI-backed APIs, WebSocket and SSE endpoints, caching, sessions, auth, CSRF and many common web concerns with one coherent registry. It compiles and freezes the whole app at to_app time so routing and guards run as cheap lookups and handlers are plain coderefs, which makes request dispatch very efficient. The toolchain includes generators and dev commands to scaffold projects from OpenAPI, run a dev server, inspect routes and run tests with an in-process client. Plugins and view engines extend the core and named routes, mounts and a simple publish/subscribe bus let you build multi-worker apps while features like a C ABI and async futures give low-level observability and nonblocking handlers for evented servers. Punk also documents the operational tradeoffs it makes. Some features such as nonblocking WebSockets, the shared message ring and optimal performance assume Hyperman or compatible PSGI servers. If you want a batteries-included Perl web framework that prioritizes runtime efficiency, sane boot-time validation and easy OpenAPI integration, Punk is worth a look.

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.