CPANscan

Perl::Critic::Policy::ProhibitNoWarningsRedefine is a linting rule for Perl that stops you from turning off the "redefine" warning, a common but risky shortcut used when tests replace existing subs by hand because it can hide typos that install new, unused symbols and let tests pass incorrectly. The policy flags explicit no warnings 'redefine' and even a bare no warnings since that also suppresses the category, and it recommends using Test::MockModule instead because that checks the sub exists, scopes the mock, and restores the original at scope exit without disabling warnings. You can configure which warning categories are forbidden, the default is "redefine", and the policy is intended for test and maintenance code with high severity to help avoid subtle, hard‑to‑find bugs.

Perl::Critic::Policy::RequireFatalWarnings is a linting policy that insists Perl files turn Perl-raised warnings into fatal errors by using use warnings FATAL => 'all' instead of plain use warnings or no warnings at all, so problems like uninitialized values fail fast instead of getting buried in logs. It helps catch subtle bugs early in development and in long running programs by forcing execution to stop where Perl itself raises a warning. The policy can be told about equivalent modules that already enable fatal warnings for you so it does not produce false positives. Be aware that making warnings fatal in a module used by others can cause callers to die unexpectedly, which is why this rule is opt in for many distributions.

Lucy is a Perl interface to a high-performance, modular full‑text search engine that makes it easy to index and search large document collections with features such as incremental and near‑real‑time updates, Unicode-aware analysis, boolean and phrase queries, stemming, stoplists, customizable analyzers, result highlighting, and flexible sorting. It offers both a full-featured API for building complex indexing and query pipelines and a simpler Lucy::Simple wrapper plus tutorials for quick starts. Distributed search support exists via companion LucyX::Remote modules which are no longer shipped on CPAN but remain available from the project repository. The recent 0.8.0 release fixes several security issues and robustness bugs. Be aware that the main Lucy namespace is an API-unstable development branch, the library is not thread-safe, and some exceptions can leak memory. Lucy is distributed under the Apache 2.0 license.

Catalyst::Seal is a drop-in performance addon for Catalyst web apps that freezes the application at setup and compiles its runtime metadata into constant, fast paths so requests do far less work. You enable it by putting use Catalyst::Seal above use Catalyst in your app and nothing else changes in your code. At a high level it makes the application immutable, replaces repeated metaobject lookups and wrapper trampolines with constant or XS accessors, memoizes frequent action and encoding decisions, avoids rebuilding common structures like headers and canonical URIs, and skips or defers work that cannot change after setup. The net effect is a large reduction in per-request overhead and a several-fold increase in throughput in benchmarks, for example improving a simple app from about 6.6k to about 20.4k requests per second in the author’s tests. There is a hard kill switch via the CATALYST_SEAL environment variable and a debug flag to report what was sealed. This is the initial 0.01 release.

MIDI::Util is a compact collection of helper routines for creating, inspecting and playing MIDI from Perl, designed to sit alongside MIDI::Simple and make common tasks easier. It gives you setup_score to build a ready-to-use score with sensible defaults like tempo, channel, patch and optional lead-in, utilities to normalize note names and compute duration sizes and ticks, functions to inspect internal MIDI tables and produce reverse lookups, and simple ways to set time signatures and channel patches. It also computes timing in microseconds, converts a MIDI::Simple score into raw event arrays, and can generate timidity configuration snippets or drive timidity and fluidsynth for immediate playback. Nothing is exported by default so you import just the helpers you need. This module is useful if you generate MIDI programmatically, need quick utilities for debugging or transforming MIDI data, or want a straightforward path to play scores through software synths.

Perl::Critic::Policy::RequireQwForLiteralLists is a Perl::Critic rule that spots runs of plain quoted words used as a list and recommends replacing them with a qw() literal to make command-style argument lists shorter and easier to read. It emits a single low-severity violation per run and lets you configure how long a sequence must be before it triggers (min_run_length, default 3), so very short lists are left alone. The policy ignores cases where qw() would change meaning, for example interpolated strings, items containing whitespace or escapes, and hash initializers, and it will not detect a run that is split by an existing qw() fragment. This is a cosmetic maintenance rule intended to reduce punctuation noise and clarify intent in Perl list usage.

Perl::Critic::Policy::ProhibitUsageSubs is a Perl::Critic rule that helps prevent duplication of a script's command line documentation by flagging locally defined subroutines named usage, _usage, print_usage, usage_message, help or other names you configure that return usage text. It encourages you to document the interface once in POD and call Pod::Usage or pod2usage to display it, which avoids the common problem of a hand-rolled usage sub getting out of sync with the real documentation. The policy reports actual sub declarations with the configured names but permits calls to pod2usage and imported usage functions and does not flag forward declarations. The list of names is configurable and the rule focuses on maintainability and documentation quality while noting that it can only detect problems by name so unrelated functions using the same name may be reported.

Perl::Critic::Policy::ProhibitUseLib is a lint rule for Perl::Critic that flags fragile uses of the lib pragma such as use lib "$FindBin::Bin/../lib" or hardcoded paths, because those hand-written @INC additions break when scripts move and can load the wrong or stale modules. It encourages using FindBin::libs which walks up from the script and finds the correct lib directory automatically. The policy detects configured pragma names (defaulting to lib and lib::relative), leaves no lib alone, and only reports explicit use statements so other ways of mutating @INC are not caught. It is a medium severity rule aimed at improving maintenance and portability. This is the initial 1.000 release.

Music::Scales is a small Perl library that generates musical scales from a given keynote and scale name, returning note names, semitone offset maps, MIDI note numbers, or PDL-style note strings so you can plug scale data straight into MIDI, analysis or notation code. It understands a wide range of modes and scale types from common ones like major, minor, harmonic and melodic minor, pentatonic and blues through chromatic, whole-tone and several exotic scales, and it accepts abbreviated scale names for convenience. You can request ascending or descending variants where applicable, get enharmonic spellings chosen to match the key or force sharps or flats, and quickly test whether a name is a valid scale. The module exports simple functions for these tasks and is handy for music scripting and prototyping, though the author notes a few remaining enharmonic edge cases and lists additional scale types and microtone support as future work.

MooX::Tag::TO_HASH is a Moo role that gives you a simple, declarative way to turn Moo objects into plain Perl hashes for serialization or inspection. You mark attributes with the to_hash option when you declare them and then call the TO_HASH method on an instance to get a hash of only those fields. You can rename keys and control inclusion with flags such as if_exists which includes a key only if the attribute was set, if_defined which requires a defined value, and no_recurse which prevents the module from walking into nested arrays, hashes, or objects. Attributes inherited from parent classes or roles are handled automatically. If your class needs to tweak the produced hash you can implement a _modify_hashr or modify_hashr method to edit the hash in place. Previously recommended use of method modifiers to change the output is discouraged because it can behave incorrectly with inherited roles. This module is a lightweight, configurable choice when you need predictable, attribute-level control over how Moo objects are converted to hashes for JSON, APIs, debugging, or persistence.

Playwright is a Perl client that lets you control modern browsers via Playwright by talking to a small Node.js proxy server, exposing Playwright concepts as familiar Perl objects like Browser, Page, BrowserContext, ElementHandle and Locator so you can navigate pages, query and interact with the DOM, run JavaScript, handle events and await asynchronous operations from Perl code. The module can auto-check and help install required node dependencies but you may need to set NODE_PATH or use nvm to ensure a recent Node.js is available. It adapts Playwright naming to Perl by providing select/selectMulti and related helpers, wraps evaluate calls so script bodies behave like function bodies and translates ElementHandle arguments into DOM nodes for you. Advanced features include connecting to remote playwright_server instances or Chrome CDP endpoints, saving videos and downloads via saveAs, issuing arbitrary HTTP requests through an APIRequestContext, and helpers for timeout management and test-style workflows. The project is actively maintained and the recent 1.621 release updates compatibility with a newer Playwright version, refreshes the video API example and improves guidance about NODE_PATH.

SimpleFlow is a compact, pure-Perl workflow manager and logger that makes long shell pipelines easier to run, debug and reproduce. You express each step with a single task() call and SimpleFlow checks inputs and outputs, times the command, captures stdout, stderr, exit code and signal, logs a structured record and skips work that is already done unless you force overwrite. It supports dry runs, quiet logging, running commands without a shell by passing cmd as an array ref, optional stale-file checking like make or snakemake, and a POSIX-only timeout that kills a whole process group if a step hangs. task() always returns a detailed hashref so callers can inspect outcomes, and say2() prints a timestamped message to both STDOUT and a log file. Note that SimpleFlow runs the command you give it via system, so keeping the commands themselves portable across platforms is your responsibility.

EV::WebKit is a Perl module for driving a real, in-process WebKitGTK 6.0 (GTK4) browser from the EV event loop, providing asynchronous, callback-driven automation for navigation, DOM queries and manipulation, JavaScript execution, screenshots and PDF export, downloads and uploads, cookie management, request/response interception, and device fingerprinting including optional network-level impersonation via a local proxy. It exposes lightweight element handles, supports frame addressing, user scripts and styles, a visible minimal chrome mode or headless use under xvfb, and integrates cleanly with other EV-based code because it bridges WebKitGTK into EV via EV::Glib. The implementation is pure Perl over GObject Introspection with a small optional compiled web-process extension for extra features. It requires WebKitGTK/GTK4/JavaScriptCore/libsoup typelibs and an X display or xvfb to run and may need container privileges or sandbox tweaks for WebKit’s bubblewrap. In the 0.02 release fingerprint profiles now apply inside Worker and SharedWorker scopes and a new fonts option lets you control the font set the page can see.

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.