CPANscan

Syntax::Operator::Equ adds tidy, undef-aware equality operators to Perl so you can test strings or numbers while treating undef as its own distinct value rather than as the empty string or zero. It provides the infix operator equ for string equality and === for numeric equality, both of which return true when both sides are undef, false when exactly one side is undef, and otherwise behave like normal eq or == without producing uninitialized-value warnings. For older Perls that lack custom infix support you can still use the same tests via wrapper functions is_strequ and is_numequ or via XS::Parse::Infix and Syntax::Keyword::Match, and the wrappers are written so they are usually inlined for good performance. Note that this behavior has been adopted into Perl itself as PPC0030 and appears in core from Perl 5.45.3 onward, so the module remains useful on earlier releases but is redundant on that and later core versions.

Proxy::Impersonate is a small EV-driven local forward proxy that lets a client like EV::WebKit present the connection fingerprint of a real browser to upstream servers by terminating TLS on localhost and re-originating each request through Curl::Impersonate so the origin sees the chosen browser's TLS and HTTP/2 fingerprints. It is designed to be used as an HTTP/HTTPS proxy for tooling that cannot itself reproduce a browser handshake and provides per-request hooks to rewrite, mock, or block requests and to observe or modify response headers while still verifying the real origin certificate upstream by default. It is not a full browser replacement: HTTP/3, WebSockets and streaming uploads are out of scope, request bodies are buffered, and some header-order and HTTP/2 priority nuances are not reproduced exactly. Because WebKitGTK cannot be told to trust a custom CA the proxy uses a local self-signed cert and expects the client to accept it on the localhost hop. In the recent 0.02 release upstream responses are now decompressed before being forwarded so pages served with encodings the client cannot decode (for example zstd) render correctly and the module now requires Curl::Impersonate 0.02.

Curl::Impersonate is a Perl HTTP client that drives a patched libcurl (libcurl-impersonate via Alien::curlimpersonate) so your requests carry a real browser's TLS (JA3/JA4) and HTTP/2 connection fingerprint, making it useful when you need connections to look like specific browsers. It is an HTTP client rather than a full browser so it does not execute JavaScript and currently does not cover HTTP/3 or WebSockets. You can use it synchronously or concurrently with a curl_multi-based Multi interface that supports streaming responses, backpressure, and event-loop integration, and it verifies TLS by default while allowing options like timeouts, proxies, header control and redirect behavior. Note that a proxy that terminates TLS will present its own fingerprint unless you tunnel with CONNECT. Installing the module builds libcurl-impersonate at install time so a C/C++ toolchain plus cmake, ninja, go and patch are required. Recent releases added a decode option to let libcurl decompress response bodies for you.

Cpanel::JSON::XS is a fast, C-backed JSON encoder/decoder for Perl maintained as a cPanel fork of JSON::XS that focuses on correctness and Unicode handling. It offers both simple functional helpers and a configurable object interface to control encoding details such as UTF-8/ASCII/Latin1 output, pretty printing, canonical key sorting, handling of blessed objects, big-number support, relaxed parsing extensions, incremental parsing for streams, and BOM detection. The module aims to preserve round-trip integrity, is thread-safe, interoperates with JSON::MaybeXS, and provides security-conscious defaults while letting you opt into more lenient behavior. Recent notable updates include making non-reference top-level values accepted by default for compatibility with the broader Perl JSON ecosystem while keeping an option to require array or object top-levels for stricter security, and a 2026 fix that prevents an infinite loop when sorting malformed UTF-8 hash keys. Use Cpanel::JSON::XS when you need a high-performance, well-tested JSON layer in Perl that handles Unicode and edge cases reliably.

App::Netdisco is an open source, web-based network management application that inventories and maps your switches and routers by collecting SNMP data into a PostgreSQL database and presenting it via a built-in web UI and backend daemon. Network engineers can use it to locate a host by MAC or IP and see the switch port it sits on, change port state or VLAN and PoE settings, run discovery and polling jobs, and produce inventory and topology views for troubleshooting and reporting. It installs on a standard Perl/Postgres stack and can be run in a self-contained user environment or via provided container images, with command-line tools for deployment, discovery and job control and a DBIx::Class API for integrations and plugins. The project is actively maintained and recent releases modernized the frontend libraries, improved SNMP support (including better Cisco WLC handling), and added performance and API refinements, so it is a good fit if you need an open, extensible tool to discover, track and control layer‑2/3 network devices.

SPVM::Go brings Go-style concurrency to SPVM by providing lightweight goroutines and channels so you can run many concurrent tasks and pass data between them with a familiar Go-like API. You spawn tasks with Go->go, create buffered channels with Go->make, use select-like primitives and wait or sleep with timeout-aware methods for IO and timers. The runtime integrates libuv to drive timers, socket IO and channel waits so goroutines suspend without busy waiting and the process consumes almost no CPU while idle, making it practical to run thousands of goroutines in a single process. Several scheduler operations must be invoked from the main thread and IO timeouts raise Go::Error::IOTimeout exceptions. The distribution also provides helpers such as Go::Select, Go::Sync::WaitGroup and Go::Context and respects the SPVM_GO_DEBUG environment variable for debugging. If you need scalable, low-CPU asynchronous concurrency in SPVM, this module is a good fit and recent work focused on replacing polling with a libuv-backed event loop to improve efficiency and robustness.

Syntax::Keyword::Assert provides a simple assert keyword for Perl so you can write inline checks that die with a clear, user-friendly message when a condition fails but disappear with zero runtime cost when you disable them before loading the module. Assertions are enabled by default and can be turned off by setting $ENV{PERL_ASSERT_ENABLED} to a false value in a BEGIN block, in which case the asserts are removed at compile time so there is no performance penalty in production. You can pass an optional custom message that is evaluated lazily only on failure so expensive diagnostics are not computed when assertions pass. The keyword is lexically scoped and can be imported into other modules via import_into for toolkits, and it can be explicitly unimported so the name reverts to a normal function call. Error messages have been improved over time to include common operators and isa checks. Recent updates added lazy-evaluated messages and custom message support, and the latest release documents unimport behavior and adds compatibility with modern Perl releases.

Heap::PQ is a C-backed binary heap for Perl that gives you efficient min or max priority queues with a choice of interfaces: a traditional OO API, a functional API with compile-time optimized ops, and a raw array API for maximum speed. It supports push, pop, peek, peek_n, search and delete, and lets you supply a custom comparator or a dot-separated key path so numeric keys are extracted at push time and comparisons run in C for extra performance. There is a numeric-only variant that stores native doubles to avoid SV overhead. The OO interface intentionally does not use the compile-time ops so it is slightly slower than the functional and raw APIs. If you need fast, low-overhead priority queues for schedulers, leaderboards, k-largest problems or similar tasks, Heap::PQ is a compact, high-performance option.

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.