CPANscan

Tk::GtkSettings is a small Perl module that helps Perl/Tk applications match the look of GTK desktops by reading your GTK configuration and applying its fonts and colors to Tk via X resources. It provides a one-call convenience function applyGtkSettings plus more granular tools to load GTK files, decode GTK font and color formats, generate xrdb/Xresources/Xdefaults output, and manage groups of widget option mappings so you can tweak or extend which Tk widgets get themed. It only operates on Unix/X11 systems and is harmless on Windows and Mac where it simply does nothing, and it works under the module’s assumption of 8-bit color depth when adjusting colors. If you want your legacy Perl/Tk GUIs to blend with modern GTK themes without hand-tweaking every color and font, this module makes that straightforward. Recent releases have broadened widget coverage and added refinements such as a new guideColor option for the ListBrowser widget to better match desktop themes.

Getopt::Guided is a Perl module for parsing command line options that follows the POSIX getopts rules while adding modern conveniences for script authors. It provides an iterator-style getopts() that writes parsed flags and option values into a user-supplied hash and can operate on a supplied argv array, and it offers processopts() to bind parsed options directly to scalars, arrays, hashes, or callback functions so you can implement option semantics like version or help handling in order of precedence. The module supports common, multi-value (list) and key=value (map) arguments, negatable and incrementable flags for patterns such as verbosity, and it will restore @ARGV and warn on parse errors rather than leaving a half-parsed state. readopts() can prepend defaults from a simple rcfile and print_version_info() helps implement a standard -V behavior. Recent updates added true HASH destinations and explicit map option support and improved robustness by catching exceptions raised by callback handlers, making the module a safe, POSIX-compliant choice when you want predictable, flexible option parsing in Perl scripts.

Mail::Milter::Authentication is a Perl milter daemon that integrates email authentication into your mail flow by applying and reporting on standards like SPF, DKIM, DMARC, ARC and BIMI. It runs as a preforking Net::Server process and is built from modular handler components so you can enable policy checks, RBL lookups, DMARC reporting, metrics and custom processing without rewriting the server. The module handles logging, metrics export, and rejection or quarantine actions when policies require it and provides hooks and protocol-specific classes for extending behavior. It is aimed at mail server operators who want a configurable, extensible way to enforce and report on modern email authentication, and the latest release fixes a DNS timeout cache recursion with Mail::DMARC 2.x that could otherwise exhaust process memory.

Affix is a high-performance Foreign Function Interface for Perl that lets you call native C, Rust, C++, Go, Fortran, assembly and other code directly from Perl without XS or external compilers by generating JIT trampolines for near-native call speed. It provides a rich, C-like type system for primitives, pointers, structs, unions, enums, SIMD vectors and variadic functions, plus zero-copy "live" views that map Perl hashes and arrays directly onto C memory, managed allocation helpers, pointer arithmetic, callbacks, library discovery and a suite of debugging and introspection tools. If you need to bind functions, manipulate raw memory, pass Perl subs into native callbacks, or build fast language bridges, Affix gives you a full toolkit that works cross-platform. The recent v1.1.0 release delivers a major V2 Pin system backed by Perl magic VTables to eliminate tied-variable overhead for memory access, a new Const[...] wrapper to enforce read-only C memory at the Perl level, improved bitfield and enum handling, and numerous ABI and platform fixes. Note that some global operations such as registering types or bindings are not thread-safe and should be done in the main thread before spawning worker threads.

Zuzu is a small Perl helper for running ZuzuScript code from Perl. It provides two simple functions: zuzu_eval parses and evaluates a ZuzuScript source string and zuzu_evalfile loads a UTF-8 script file and evaluates it, with both calls returning the result of evaluation. You can pass runtime options to control execution, for example to restrict module access or add library paths, so it is convenient for quick one-off execution, embedding Zuzu snippets in Perl programs, testing scripts, or running script files without building a larger integration.

Dancer2::Plugin::OIDC makes it easy to add OpenID Connect authentication and OAuth 2.0 token validation to Dancer2 web apps. It lets your application act as an OpenID Connect Relying Party and as a Resource Server by validating access tokens issued by an external provider. The plugin wraps the OIDC-Client library, creates client objects from your configuration, automatically installs the callback routes, and exposes an oidc(...) helper that returns a request- and session-aware OIDC::Client::Plugin instance. It supports multiple providers, token exchange for calling downstream APIs, verification of access tokens and building user objects from claims. It does not implement an OpenID Provider and the author recommends storing session and token data on the backend rather than in client-side cookies.

Sys::Export is a high-level toolkit for building a trimmed-down copy of an operating system tree for things like chroot environments or initramfs images. It automates inclusion of required libraries and interpreters for the files you select, lets you rewrite paths and user or group IDs and updates references where possible, and supports injecting generated or external files into the export. The module is mainly a convenience wrapper that creates an OS-specific exporter (for example Sys::Export::Linux) and exports simple functions such as add, skip, find, rewrite_path and finish so you can script what to include without dealing with exporter objects directly. It also provides utilities for lazy file data handling, memory-mapping fallbacks, compact file-attribute shorthand, and helpers for writing file extents. If you need to assemble minimal runtime images or chroot trees this makes the job much easier, but be aware that only Linux is fully supported at the moment.

Mojolicious::Plugin::OpenAPI::Modern is a Mojolicious plugin that wires an OpenAPI::Modern object into your app so you can drive request and response validation from an OpenAPI specification. You configure it with a raw schema, a filename, a canonical document URI, or by handing it an existing OpenAPI::Modern object, then use the provided helpers in controllers to access the parsed spec via openapi and to run validate_request and validate_response to check incoming requests and outgoing responses against your API contract. The plugin also saves useful route and operation metadata in the stash under the openapi key and provides an after_response hook so you can run non-mutating response checks for logging or telemetry. Recent releases include support for explicitly setting document_uri and an after_response option, plus small fixes to keep tests and dependencies aligned with OpenAPI::Modern.

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.

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.

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.