CPANscan

Devel::MAT is a Perl Memory Analysis Tool for loading and inspecting heap dump (.pmat) files so you can diagnose memory leaks and understand what is keeping data alive in a running program. It wraps a dumpfile and exposes a set of analysis Tools and a simple UI that let you explore Perl scalar/array/hash/code values, trace inrefs and outrefs back to roots, locate symbols, globs and stashes, and run commands to count, size or diff objects. The toolset is extensible via a Devel::MAT::Tool API so third‑party modules can add custom analyses or UI pages. The dump format has been made more extensible over time to ease forward compatibility and the project is actively maintained; a recent update modernised the code for Perl 5.20 and fixed a bug in the show command by adding the missing show_UNDEF handler.

Syntax::Kamelon is a fast, programmable syntax highlighting and code folding engine that uses Kate editor XML definition files to recognize and format source code and other structured text. It replaces the older Syntax::Highlight::Engine::Kate and loads Kate XMLs directly so you can use the existing language definitions or supply your own, while formatter plugins let you output highlighted content as HTML, ANSI, or any custom format by subclassing Syntax::Kamelon::Format::Base. The module supports hooks for custom commands on matches, can suggest a lexer by filename, and offers controls for indexing the available XMLs or rebuilding them on the fly at startup. It is well suited for server side highlighting, report generation, custom editors, and automated code formatting and runs significantly faster than earlier versions. Be aware that some upstream Kate XMLs are imperfect and a few Kate tag features were intentionally omitted, and that regex differences in newer Perl releases can produce small mismatches for a handful of definitions.

App::SlideServer is a lightweight Mojolicious web application that converts a Markdown or loose HTML file into a browser-based slideshow with a presenter interface and real-time synchronization over websockets. It automatically upgrades your source into a standard slide DOM, splits content into individual slides, injects the JavaScript and CSS needed for fullscreen presentation and presenter notes, and broadcasts slide state so multiple viewers can follow or a remote device can control the show. The module supports stepwise animations via data-step attributes and automatic stepping for lists, lets you plug in your preferred Markdown processor, and can optionally watch the source file for live reloads using Linux::Inotify2. Authentication for the presenter is handled by a presenter_key and the app is easy to run as a web server or extend by subclassing. A few advanced behaviors such as scoped per-slide styles and deferred inline script execution are noted as TODO and presenter-only notes are currently enforced by CSS rather than backend filtering.

XML::PugiXML is a lightweight Perl binding for the pugixml C++ XML parser that gives you very fast parsing, XPath querying, DOM-style navigation and easy tree modification and serialization from Perl. It exposes familiar document and node methods to load or save XML, run XPath or compiled XPath expressions, read and write attributes and element text, clone or insert nodes, and control formatting options when producing output. The module expects UTF-8 input and marks all outputs as UTF-8, and it uses a reference-counted model where node and attribute handles keep the document alive but become explicitly stale if the underlying node is removed or the document is reset so you should use valid() to test handles. pugixml does not process external entities and does not expand user-defined entities by default, so it avoids common XXE and entity-expansion attacks. If you need a faster alternative to XML::LibXML for parsing, XPath, DOM traversal or manipulation, this binding is a solid choice. Recent updates (0.08) fix several memory-safety issues such as use-after-free and stale-handle corner cases, tighten handling of embedded NULs, and add thread-safety precautions by skipping cloning of internal objects across ithreads.

EV::Future is a tiny, high-performance async control-flow library for EV-based Perl programs that provides primitives like parallel, parallel_map, parallel_limit, series, series_map and race so you can run many tasks concurrently, with limits, or sequentially using a simple done-callback convention. Tasks are offered in two styles: the task form where each array element is a coderef invoked with a single done callback, and the map form where a worker is called for each data item as ($item, $done). In non-void context each call returns an EV::Future::Handle that reports active and pending counts and can cancel remaining work, which makes it easy to monitor and abort operations. The implementation is XS-optimized for low overhead and offers a safe default mode that wraps task execution and drops double-calls, plus an unsafe mode for roughly double the throughput at the cost of uncaught exceptions possibly abandoning an operation and of unsafe behavior if done is called twice. The author documents a few silent traps to watch for such as non-coderef tasks being treated as instant no-ops, tied arrays being ignored by the task form, and never handing the raw done callback directly to EV watchers. The recent 0.06 release added the map variants and series_map, introduced the EV::Future::Handle with cancel/pending/active, and bumped the minimum Perl to 5.14 while fixing several edge-case bugs.

MooX::Role::SEOTags is a small Moo role you can mix into page objects to automatically generate common SEO meta tags for web pages, including HTML title and description, canonical link, OpenGraph properties and Twitter/X cards. It expects your class to provide basic attributes such as og_title, og_type, og_description and og_url, with og_image and a few other fields optional, and offers methods to emit individual tags or grouped outputs like core_tags, og_tags, twitter_tags or a single tags call to print everything. The module is useful when you want a consistent, testable way to produce metadata for social preview and search indexing without handcrafting HTML for every page, and recent updates added a consolidated core_tags method plus support for meta title, og:site_name and og:image:alt.

Data::PerfectHash::Shared provides a tiny, immutable on-disk set that you build once and then mmap read-only from any number of processes to perform extremely fast, lock-free membership tests. It supports integer keys or arbitrary byte strings, stores the full keys on disk to guarantee zero false positives, and answers has() queries in worst-case O(1) with a very small index footprint so the same image can be shared across processes and survive restarts. You create a builder to add keys and write a .phs image, or use the convenience build_int/build_str one-shot methods, and readers use load to validate and mmap the file then call has, each_key, count, type, or unlink. The on-disk format is validated at load time to avoid misreads and bounds-checked per lookup to limit risks from untrusted files, but images are immutable and only loadable on hosts with the same byte order. Performance is excellent for read-heavy scenarios and the index is compact at roughly four bits per key. This initial release also introduces a compact CHD index that byte-packs per-bucket displacement entries (1 to 4 bytes each) for on-disk format version 2.

Statistics::Krippendorff computes Krippendorff's alpha, a flexible measure of inter‑rater agreement, from your coded data. It accepts input as an array of hashes or arrays so you can identify coders by name or by position and it handles missing values; you get the coefficient via the alpha method. The module includes built‑in distance functions for nominal, ordinal, interval and ratio data and for set‑valued annotations via Jaccard and MASI, and you can provide a custom delta function for specialized similarity measures. Small helpers let you validate units and inspect value frequencies to make sure your data meet the requirements. A recent update greatly accelerated the coincidence-matrix construction so large datasets that formerly took hours now complete in seconds.

Tk::ListBrowser is a Perl/Tk canvas widget that gives you a highly configurable, graphical list browser for desktop GUIs, letting you display items as a simple vertical list, a horizontal bar, a grid of rows or columns, or a hierarchical tree or hlist. It supports images and multiline text per item, sortable and draggable headers, optional side columns, keyboard and mouse selection, on-the-fly filtering, and a wide range of layout and cell-size options so you can tune appearance and behavior. You manipulate content programmatically with intuitive methods to add, remove, hide, show, sort, and refresh entries, and you can switch arrange modes without losing data, though tree-style hierarchies need a one-character separator to work properly. The widget is optimized for small to medium lists of a few hundred items, custom fonts can slow refresh, and there is an autorefresh mode and tools to control background refresh cycles to balance responsiveness.

SPVM::Go brings the Go programming language's concurrency model to SPVM by providing lightweight goroutines and typed channels so you can spawn many concurrent tasks and coordinate them with selects, wait groups, contexts, timers and signal helpers. The runtime uses the libuv event loop so blocked goroutines do not busy-wait but are suspended efficiently, keeping CPU usage low and allowing thousands of concurrent routines in a single process. It offers simple APIs to create goroutines, make buffered channels, wait on I/O with timeouts and sleep in nanoseconds, and notes that certain scheduler and I/O wait methods must be called from the main thread. A SPVM_GO_DEBUG environment switch is available for debugging.

Net::Connection is a lightweight Perl class for representing a single network connection as an object, letting scripts encapsulate local and remote host and port, protocol, state, process id and owner, send/receive queue sizes, and optional metadata like PID start time or wait channel. You construct instances from a hash reference and then use simple accessor methods to get values such as local_host, foreign_port, proto, pid, username, pctcpu and pctmem, with optional features to resolve numeric UIDs to usernames, perform PTR lookups for IPs, and translate port numbers to service names. The module keeps things simple and pragmatic so some fields may be undefined if not supplied and protocol and state strings are not strictly validated due to OS differences. It is a handy building block for tools that collect, normalize or display netstat-style connection information in Perl.

Proc::ProcessTable::ncps is a Perl module for producing an enhanced, optionally colorized ps-style process listing with flexible filtering, formatting and an easy string output you can print or embed in scripts. It builds on Proc::ProcessTable and uses Proc::ProcessTable::InfoString for its info column and Proc::ProcessTable::Match for advanced selection, and you control which columns appear via a simple args hash to its constructor such as showing faults, thread counts, TTY, JIDs or a final stats summary for CPU, memory and runtime. The module tries to be portable across platforms by detecting physical memory with POSIX::sysconf or sysctl and by hiding or erroring on columns the OS does not provide so it behaves sensibly on systems like OpenBSD and Linux. Recent releases improved robustness and portability by computing missing pctmem and RSS when the OS omits them, fixing OpenBSD crashes, tightening command line and option handling, and addressing Linux pctcpu inf or NaN issues in the latest update. The code is actively maintained on GitHub and is released under the Artistic License 2.0.

Google::Cloud::Kms::V1 is an auto-generated Perl client for Google Cloud Key Management Service that lets Perl applications manage keys, key rings, external key manager (EKM) connections, autokey settings and single-tenant HSM instances. It supports both high-performance gRPC over HTTP/2 and a REST transport and integrates with Google::Auth to use Application Default Credentials automatically, while handling requests and responses as typed Protocol Buffers. You construct the client with new and invoke RPC-like methods such as list_key_rings, create_key_handle, list_ekm_connections and update_autokey_config to perform KMS operations. The library is generated from the official proto definitions and is released under the Apache 2.0 license, making it a ready-to-use option for Perl developers who need authenticated programmatic access to Cloud KMS.

Proc::ProcessTable::InfoString is a small helper for producing a compact, ps-like status string from Proc::ProcessTable process objects, showing a one-letter process state code, symbolic process flags, and the wait channel. You instantiate it and optionally supply ANSI color names for the flags and wchan sections, then call info($proc) to get a human-friendly status snippet for each Proc::ProcessTable::Process; invalid input returns an empty string. Flag detail varies by platform with FreeBSD providing the richest set and Linux a subset, otherwise only state and wchan are shown. This module is handy when you want a concise readable status column for monitoring scripts or custom process-listing tools.

Proc::ProcessTable::Match provides a lightweight, composable way to test Proc::ProcessTable::Process objects against a stack of reusable checks. You construct it with an ordered list of check specifications, each naming a checker module (resolved under Proc::ProcessTable::Match::), supplying that checker's arguments, and optionally inverting its result. The match method evaluates the checks and returns true only when the full stack of checks passes and it will die if given an undefined or non Process object. This module is useful when you need to filter or search process tables programmatically and it is easy to extend by adding new checker modules in the Proc::ProcessTable::Match:: namespace.

PDF::Reuse::Barcode is a companion to PDF::Reuse that renders barcodes and QR codes directly into PDF pages so you can place machine-readable symbols at precise coordinates. It delegates pattern generation to existing barcode libraries like GD::Barcode and Barcode::Code128 and supports common symbologies such as Code128, Code39, EAN13, EAN8, UPC, several 2-of-5 variants, NW7 and QR codes, with options to scale, stretch, rotate, add or suppress human readable text, and draw a colored background box. For EAN and UPC types it can compute the check digit when not supplied, and QR generation exposes error correction level, version, module size and padding controls. You call the module from Perl alongside PDF::Reuse and pass parameters like x, y, size, xSize, ySize, prolong, text and drawbackground to control placement and appearance. Be aware that some longer "guard" bars or rotated images can look blurred on-screen though they print correctly at sufficient DPI, and you should test scanners if you change bar proportions. If you need barcode images embedded into PDFs with flexible layout and minimal fuss, this module provides a straightforward, library-backed way to do it.

PDF::Reuse is a Perl library for fast, programmatic reuse and mass production of PDF files that lets you assemble new documents from existing pages, forms and images while adding text, bookmarks, links and JavaScript, so it is ideal for templated output, mail‑merge and stamping workflows. It exposes both convenient high level routines and low level PDF operators so you can import pages or images, embed TrueType fonts with UTF‑8 support via prTTFont, attach or run JavaScript, create compact reusable XObjects and log document changes for archiving. The module targets PDF‑1.4 with some experimental PDF‑1.5 features, so complex newer features and JavaScript behavior can vary by Acrobat version, and some metadata, encryption and other PDF features are not handled by the module itself.

CGI::Lingua helps CGI applications choose the best language, region, and locale settings for each visitor by negotiating Accept-Language headers, inspecting user agent hints, and falling back to IP-based geolocation; you tell it which language codes your site supports and it returns a human readable language name, a two letter language or country code, a sublanguage name, a Locale::Object::Country, an IANA time zone, text direction, and CLDR-style plural categories so you can show the correct wording and layout for users. It integrates with CHI for caching and can use local Geo::IP or IP::Country databases or online services for country and timezone lookup, and it also offers a helper to find the best translation file on disk for the negotiated language. The module covers many real-world cases like sublanguage fallback (for example US versus UK English), right-to-left detection for major RTL languages, and plural rules for roughly 70 languages, while documenting a few practical limitations such as embedded plural rules that truncate fractions and are not a full Locale::CLDR replacement, is_rtl only covering primary-script RTL languages, slower and less reliable Whois fallbacks when local geo modules are absent, and the requirement that any logger you pass in be a blessed object with warn/info/error methods. If you need robust, request-level language and region negotiation for a Perl web app and can provide or tolerate local geo libraries and a CHI cache, CGI::Lingua is a pragmatic and well-documented choice.

OpenAPI::Modern validates HTTP requests and responses against OpenAPI v3.0, v3.1 and v3.2 documents and uses JSON::Schema::Modern to perform full, spec‑compliant JSON Schema evaluation. It converts incoming request and response objects into Mojolicious message types and returns rich result objects that include deserialized parameter, header, cookie and body data along with precise error locations, making it easy to see why a message failed validation. The module understands many OpenAPI features such as path, query and cookie parameter styles, media‑type decoding (including application/json and application/x-www-form-urlencoded), content encodings and default population, and it bundles up‑to‑date metaschemas so you can validate or extend schemas immediately. You can preload and cache documents for faster startup in preforked apps. Be aware that multipart bodies are not yet implemented and the Authorization header is not automatically checked against security schemes, and conversions from non‑Mojolicious message types are best‑effort and may reveal differences in header handling. Recent updates improved path matching for URL‑escaped characters and fixed edge cases involving the root path.

Alien::NLopt is a helper module that makes it easy for Perl code to find or install the NLopt C library, a widely used toolkit for nonlinear optimization. If you are a Perl developer who needs NLopt functionality or a user installing a Perl distribution that depends on NLopt, this module automates locating an existing system installation or building and installing the library for you so you do not have to manage the native dependency by hand. It is built on the Alien::Build ecosystem and is suitable for packaging or deployment workflows where native libraries must be provided to Perl modules. The project is open source under the GPLv3 and its source and bug tracker are available on Codeberg.

Google::Cloud::PubSub::V1 is a Perl client for the Google Cloud Pub/Sub V1 API that uses a high-performance gRPC transport to let Perl programs publish messages, subscribe to topics, and manage subscriptions. The module is auto-generated from the protocol buffers schema and exposes service classes that mirror the Pub/Sub API, so you instantiate a client with Google::Auth credentials and call the usual publish and subscription methods without dealing with low-level gRPC plumbing. It is aimed at developers who need low-latency, programmatic access to Pub/Sub from Perl and includes documentation with dual-transport examples. The code is Apache 2.0 licensed and the recent 0.03 release notes indicate regenerated clients with separate service classes and improved POD documentation.

Google::Cloud::NetworkServices::V1 is a Perl client for Google Cloud Network Services V1 with a focus on Secure Web Proxy functionality. It gives Perl applications a straightforward way to call the Network Services API over high-performance gRPC and integrates with Google::Auth for credential handling. The package is auto-generated from Protocol Buffers so it exposes the service methods you need to manage proxy and network resources in Google Cloud while including usage examples for different transports. It is released under Apache 2.0 and is a new, actively maintained binding that is suitable for developers who need programmatic access to Google Cloud Network Services from Perl.

Google::Cloud::NetworkSecurity::V1 is a Perl client library for Google Cloud's Network Security V1 API that uses gRPC for high-performance, low-latency calls and integrates with Google::Auth for authentication. It provides generated service classes so your Perl code can manage Network Security resources such as address groups without working directly with protobufs or raw HTTP calls. The module is auto-generated from the protocol buffer schema, is available under the Apache 2.0 license, and includes example documentation showing gRPC and alternate transport usage. The recent 0.03 release added separate service classes, fixed regexes, and improved POD with dual-transport examples and encoded proto path information.

Google::Cloud::Dataflow::V1Beta3 is a Perl client for the Google Cloud Dataflow V1Beta3 API that uses a high-performance gRPC transport to let Perl applications create, manage, and monitor Dataflow jobs and pipelines programmatically. It integrates with Google::Auth for authentication and is designed for developers who want to embed Dataflow operations into scripts, automation, or backend services. The module targets the V1Beta3 API surface and is distributed under the Apache 2.0 license.

Google::Cloud::Bigquery::Storage::V1 is a Perl client library that lets Perl programs access the Google Cloud BigQuery Storage API over a high-performance gRPC transport. It is designed for efficient, low-latency access to large BigQuery result sets and streaming reads, integrates with Google::Auth for credential handling, and is useful when you need to move sizable datasets between BigQuery and Perl applications. The module is distributed under the Apache 2.0 license.

Net::WebSocket::EVx is a lightweight Perl binding that hooks the wslay WebSocket C library into the EV event loop so you can drive WebSocket I/O from nonblocking sockets with low overhead. It expects you to perform the HTTP upgrade yourself and then hand it a socket, and it provides high level features such as message and frame callbacks, optional buffering for large payloads, fragmented message streaming, send-queue management, explicit RSV bit control for extensions like permessage-deflate, and convenient start/stop flow control. The API mirrors wslay semantics so you can queue normal or control frames, stream big binary data from callbacks, and wait for the send queue to drain before closing. The module duplicates the file descriptor so ownership is clear and it ties the object to the EV loop it was created on. Note that it is Unix focused and has incomplete Win32 support and that you must handle the WebSocket handshake yourself and set allowed RSV bits appropriately when using compression.

Params::Validate::Strict is a schema-driven parameter validator for Perl that checks, coerces and documents input against a rich, reusable specification. You declare a schema (as a hash or ordered array of field specs) describing types like string, integer, number, boolean, arrayref, hashref, object, coderef, scalar, scalarref and the new void type, plus nested schemas, per-element rules, transformations, defaults, optional/nullable flags, callbacks, custom types, cross-field checks and relationship constraints, and the module returns a new hash or array of validated, coerced values or croaks with a clear error. Transformations run before validation so you can normalise input, and there are hooks for logging and handling unknown parameters. Note that the module does not untaint values and accepts caller-supplied regexes so you should avoid pathological patterns on untrusted data. The recent 0.37 release added a dedicated "void" type for asserting undef results and documented the existing unix_timestamp semantic check.

Termbox::PP is a lightweight, pure-Perl implementation of the termbox2 terminal UI library that makes it easy to build simple text-based interfaces. It gives you a small, consistent API for drawing into a cell-based back buffer, flushing updates to the screen, and receiving keyboard, mouse and resize events while supporting colors and terminal attributes. Because it is written entirely in Perl it requires no XS or external C libraries on Unix-like systems, though Windows support needs additional Win32 modules. The module can optionally enable extended grapheme cluster handling and varying color modes via compile-time options and it registers itself as Termbox.pm so you must load Termbox::PP before using Termbox. It is designed for portability and simplicity and aims to mirror the upstream C behavior, but it is still relatively new and may evolve as real-world usage reveals needs.

Sim::OPT is a Perl toolkit for automating optimization and parametric exploration of simulation models that use text files for input and output. It drives batch experiments by morphing model parameters, running block-based searches that can overlap, and mixing sequential and parallel update strategies analogous to Gauss-Seidel and Jacobi methods. The distribution includes modules to create metamodels from sparse results, to perform specialized search strategies such as star and factorial designs, and to manipulate models for specific platforms like the ESP-r building performance simulator, plus utilities for converting plots and tweaking shading calculations. You configure searches with simple text files and can run either new simulations or analyses from precomputed datasets, while example scripts and packaged demos show common workflows for ESP-r and EnergyPlus. The package installs via cpanm, exposes a convenient opt launcher, targets Linux environments, and is available under a dual open-source/proprietary license with the GPLv3 source on CPAN.

DateTime::Format::W3CDTF is a compact Perl module for parsing and formatting dates and times in the W3CDTF form, an ISO 8601 profile commonly used by RSS 1.0. It converts W3CDTF strings into DateTime objects and vice versa, and includes a strict mode that requires timezones as part of the input and output. It also offers a format_date helper to emit date-only strings. Note that the API is marked experimental and may change, parse_datetime may die on malformed input, and format_datetime no longer attempts to truncate DateTime objects that represent midnight because DateTime does not distinguish between a missing time and midnight.