CPANscan

Medusa::XS is a high-performance audit logger for Perl that lets you mark subs with the :Audit attribute so every call automatically emits entry and exit records containing arguments, return values, a unique GUID, caller stack, timestamp and elapsed time. The module implements the hot paths in C for speed and exposes a simple configuration hash %Medusa::XS::LOG you can set at import or runtime to control log file, level, time zone and formatting. It ships with a default XS file logger but allows you to provide a LOG_INIT coderef or your own logger object, and you can also wrap subs programmatically or call helpers like generate_guid, format_time and dump_sv. If you need compact, low-overhead, automatic audit trails for method calls in a Perl application this module is directly relevant, and if you override the message formatter with a Perl coderef be aware that the built-in zero-allocation C formatter will be bypassed.

Data::MARC::Validator::Report is a small, focused data-object for holding the output of MARC validation runs. It records a required DateTime timestamp and a list of plugin report objects, validating types at construction so you get a consistent structure of Data::MARC::Validator::Report::Plugin entries and their errors. Use it as a lightweight container for assembling, inspecting, dumping or serializing validator results alongside the companion Plugin and Error objects. The module is built with Mo and enforces that plugins are the correct object type. The current 0.03 release makes a documentation example fix.

Authen::Radius is a simple Perl client library for talking to RADIUS servers, letting your script build and send RADIUS requests and receive and parse responses. It provides convenience methods for common tasks such as checking a user password, adding arbitrary RADIUS attributes (including vendor and tagged attributes), loading standard dictionaries (FreeRADIUS or GNU Radius) so attribute names and types are translated, and sending/receiving many RADIUS packet types including accounting and CoA. The constructor supports options like server host/port, shared secret, local bind address, RFC3579 message-authenticator support, timeouts, debugging and a NodeList for talking to a cluster of RADIUS nodes with simple active-node discovery. Error codes and human-readable error strings are exposed for diagnostics, so this module is useful if you need to integrate RADIUS authentication or accounting into a Perl application.

marc-validator is a command-line tool for checking MARC library records against the rules and tests provided by the MARC::Validator framework, aimed at librarians, cataloging staff, and metadata engineers who need a fast way to spot syntax errors and cataloging issues in bulk. It reads MARC files and runs configurable validation plugins and filters, supports selecting or excluding plugins on the fly, can emit recommendations as well as strict errors, and lets you specify how to identify each record so reports match your workflow. Recent updates added a plugin exclusion option (-u), support for recommendation output (-r), plugin filtering (-f) and a configurable record id (-i), and the tool has been updated to work with MARC::Validator 0.14.

Graphics::Framebuffer is a lightweight Perl library for drawing directly to a Linux console framebuffer, providing simple, well named methods to plot pixels, draw shapes, fill gradients, blit and transform image blocks, load and play animated images, and render TrueType text. It is designed for exclusive console use and includes an emulation mode so you can develop or use it on systems without a real framebuffer. The module can offload heavy work to the Imager library and optional C acceleration but always offers pure Perl fallbacks, and you can toggle acceleration when needed. It requires an open framebuffer device and will not run inside X or Wayland, and some proprietary GPU drivers with DRM are incompatible, so 24/32 bit modes are recommended for best results. With clipping, multiple draw modes (alpha, XOR, mask, add, subtract), blitting primitives, and basic mouse support, it is a practical choice for console media players, embedded displays, or simple offscreen rendering on Linux.

Rope is a compact Perl object system built on tied hashes that gives you declarative, ordered objects with modern conveniences such as inheritance, roles, method modifiers, and runtime meta manipulation. You define properties with rich options like type checking, builders, triggers, readonly or private flags, predicates and clearers, and control whether keys are enumerable or locked into place, and you can add functions, factories and chains for more dynamic behavior. It includes helpers to build objects from nested hashes or arrays, optional autoload or monkey patch accessor styles, and a small type layer via Rope::Type. Be aware that hooks behave specially when the property value is a code reference and that in long running processes you should call destroy to ensure proper cleanup. If you want a lightweight, featureful and ordered object layer in Perl without a heavy framework, Rope is worth a look.

App::FirefoxMultiAccountContainersUtils provides a set of small command line tools for managing Firefox Multi‑Account Containers from the shell. It lets you list and dump container data, add new containers, batch modify or delete containers with Perl code, sort container order using Sort::Sub modules, and open URLs directly in a chosen container, so you can automate tasks like renaming, changing icons or colors, reordering many containers, and launching links into specific container sessions. The open-firefox-container command works via the add-on’s external protocol handler and requires the Multi‑Account Containers add-on plus the "Open external links in a container" helper and can pass extra Firefox options; it also gained a --new-window option in the latest release. Several utilities support a dry-run mode so you can preview changes before applying them.

Data::Validate::Sanctions is a lightweight Perl module for checking a person’s name and optional identity details against public sanctions lists such as OFAC, EU, UK and MOHA, returning a simple yes/no or a detailed match report with the source and matched fields. It provides both a procedural and an object-oriented interface, normalizes names before matching, can fetch and cache upstream CSV or XML lists, export cached data, and report when lists were last updated. You can point it at a local file, set the path via environment, or let it update lists for you, and the get_sanctioned_info method returns which fields matched when a hit occurs. Recent releases improve MOHA support by parsing the new xmlResponse format, extracting multiple dates of birth and passport numbers from concatenated fields, and fixing EU token handling.

Business::UDC is a compact Perl module for parsing and validating Universal Decimal Classification (UDC) notation. You create an object with a UDC string and the module will tell you if the string is syntactically valid, provide a token list and an abstract syntax tree for programmatic inspection, and expose the original source and any parse error. It is handy for library, cataloging, or data-processing tools that need to interpret or validate UDC codes. The author notes that error reporting is a TODO item, so error messages may be limited in detail.

MARC::Validator is a lightweight, plugin-driven toolkit for checking MARC bibliographic records against a growing set of field-level rules. It discovers available plugins and exposes them via a simple plugins method so you can see which validators are installed and run checks for common issues such as bad or missing ISBNs in 020, duplicate 035a identifiers, 040 metadata problems, content flags in 008/leader used by field checks, presence of illustrations or indexes, genre headings like comics or manga in 655, and universal decimal classification checks in 080. The module uses Module::Pluggable to load validators and is intended for library-systems developers or cataloguers who need automated, extensible validation rather than a monolithic linter. Note that the plugin API recently changed to rename struct() to report() and the 0.14 release also added the 080 plugin and improved handling for manga in 655 while cleaning up some leader/008 related error reporting. The project is hosted on GitHub for reference and contributions.

Legba is a small Perl XS module that provides fast, global named storage slots reachable from any package. You import slot names and get simple accessor functions that return the current value when called with no arguments and set the value when given one. It is implemented in XS using custom ops and direct SV pointers for performance, and also offers dynamic APIs like _get, _set, _exists, _delete, _keys and _clear for programmatic access. For advanced use it exposes the internal registry SV, raw SV pointers and helpers to create getter and setter ops for optree injection. Legba is handy for lightweight cross-package caches, shared configuration or session data where a small, fast global store is useful.

Business::ISBN::Data is a companion data module for Business::ISBN that supplies up-to-date ISBN registration group and range information derived from the ISBN Agency's RangeMessage.xml. It is normally loaded automatically by Business::ISBN and requires Business::ISBN 3.005 or later because the internal data structure changed to handle ISBN-13 prefixes. You can point the module at an alternate RangeMessage.xml by setting the ISBN_RANGE_MESSAGE environment variable before loading Business::ISBN, and if no external file is available the module falls back to embedded data or looks for RangeMessage.xml in the current directory. The distribution includes a copy of RangeMessage.xml and a helper script for regenerating the default data, and the project is maintained on GitHub so you can fetch updates or contribute fixes.

Tlaloc is a small, playful utility for Perl that lets you attach an invisible "wetness" meter to scalars and to tied arrays or hashes so their wetness decays each time the value is read. You control wetness with simple functions like wet and drench, inspect it with wetness, is_wet and is_dry, and tune how fast it evaporates with evap_rate. By default a wet or drenched scalar loses a fixed amount on every access so the underlying string value never changes while the hidden metadata counts down. For arrays and hashes you can either track wetness only when you explicitly query it or use wet_tie to make element access and other operations cause passive evaporation. Useful for toy state, TTL-like behavior tied to reads, or adding ephemeral metadata to variables, Tlaloc is easy to use but has a few caveats: do not pass literals, magic is per-SV so assignments do not copy wetness, and it is not thread safe. This is an early stage module with only an initial release in its change log.

Term::TablePrint is a Perl utility for displaying an array-of-arrays as an interactive, paginated table in a terminal so you can browse rows with a keyboard cursor, search with regular expressions, and expand individual rows to see each column on its own line. You can call it as a simple print_table function or as an object, and it handles paging, automatic column sizing and trimming to fit narrow terminals, right- or left-justifies numbers and text, and offers options for color, column selection, binary-data handling, whitespace squashing, decimal separators, and progress feedback when preparing large tables. Common navigation keys and vi-style shortcuts are supported and you can restrict visible columns or run case-sensitive or insensitive searches. The module expects decoded strings, a matching STDOUT encoding layer and a monospaced terminal, and requires Perl 5.16 or newer. It is a good fit when you want a quick, configurable interactive viewer for tabular data directly from Perl scripts.

Term::Choose is a small Perl library for presenting an interactive terminal menu so users can pick one or more items from a list. It provides both a simple functional choose() call and an object interface and supports single selection in scalar context and multi selection in list context with spacebar marking, keyboard navigation and optional mouse support. The display is highly configurable with options for layout, columns, alignment, paging, colors, prompts, default selections and a regex search filter, and it will update when the terminal is resized. The routine returns either the chosen items or their indices and works with decoded strings so you must ensure STDOUT uses the correct encoding and a monospaced terminal. Optional modules such as Term::ReadKey improve input and terminal size detection and Term::Choose::LineFold::XS can speed up formatting. On Windows it uses Win32::Console and offers a codepage mapping option.

SPVM is a statically typed programming language that borrows Perl's familiar syntax while aiming for higher performance and native integration. It provides static typing with type inference and analysis, ahead-of-time and just-in-time compilation, the ability to produce standalone executables, and bindings to C and C++ libraries. You can call SPVM methods from Perl and reuse many familiar Perl functions and modules, and the runtime supports both native threads and lightweight goroutines. The project ships command-line tools for running and compiling programs, analyzing dependencies, and packaging modules, and it includes documentation and examples for native bindings and extensions. Note that SPVM is still pre-1.0 and does not yet promise backward compatibility, so it is best suited for developers who want Perl-like syntax with static types and native performance and who are comfortable experimenting with a developing language.

File::Meta::Cache provides a lightweight, performance‑focused cache for open file descriptors and stat metadata so programs that repeatedly read the same files can avoid expensive stat and open calls and reduce the number of open file descriptors. It is useful for high‑frequency file access patterns such as serving static assets from a web server, and it offers both a simple OO interface and faster code‑reference APIs for hot paths. Each cached entry stores the opened file descriptor, optional filehandle, stat array and a user field where you can stash precomputed data like HTTP headers, and the cache keeps a single descriptor per file so callers must manage their own file positions when doing IO. The cache does not auto‑expire entries so you should call sweep periodically to close unused files and refresh metadata. The module is deliberately tuned for speed, exposing entries as compact arrays rather than accessor methods. Recent updates added redirected file linking support (via File::Path::Redirect) and a fix to correctly return undef when an opened redirect target does not exist.

Win32::Credentials provides a lightweight Perl interface to the Windows Credential Manager so you can store, retrieve, and delete generic credentials from Perl using simple functions cred_write, cred_read and cred_delete. It talks to the native Win32 API via Win32::API so no XS compilation is required, and stored secrets are protected by Windows DPAPI (AES-256) tied to the current Windows user account. The module stores secrets in Windows UTF-16LE format, uses CRED_TYPE_GENERIC with CRED_PERSIST_LOCAL_MACHINE, and enforces the platform limits such as a 512 byte secret size and the requirement for 64-bit Windows and 64-bit Perl. Use cred_read in scalar context to get the secret or in list context to also receive the associated username. This is a practical choice for Perl scripts on Windows that need secure, built‑in credential storage without implementing encryption themselves.

File::Path::Redirect gives you a lightweight, portable way to emulate filesystem symbolic links by using tiny text “redirect” files that point to a real file path. You create a redirect with make_redirect and resolve it at runtime with follow_redirect, which returns the first non-redirect target so you can open the actual file. This is handy on filesystems that do not support symlinks or when you need cross-volume references or want to avoid copying very large files. The module supports chained redirects with a configurable recursion limit (default 10) and reads each redirect file as it resolves so caching resolved paths is recommended for repeated access. Recent v0.1.3 fixed handling of absolute target paths and tightened how much of a candidate file is read when detecting redirects.

Clone is a small, fast XS-backed Perl module for making deep, recursive copies of scalars, arrays, hashes and references, including blessed objects, tied variables, weakened references and circular structures so you get an independent replica of complex data. It preserves tie behavior and weakened refs, avoids infinite loops on circular graphs, and documents cases where cloning shares internals such as code references or the underlying file descriptor of filehandles. Because it is implemented in C it is optimized for speed in shallow to medium-depth structures, but cloning very large or extremely deep data uses more memory and has a recursion depth limit, so for serialization-heavy or extreme-depth cases Storable::dclone may be worth benchmarking. Recent maintenance releases brought performance optimizations and multiple bug and test fixes, quieter DBI-related tests, packaging tweaks for macOS, and an AI policy document for the project.

XAO::FS is the XAO framework's database layer that lets you work with persistent, URI-addressable objects while keeping data in a normal relational database such as MySQL. It maps natural object and collection structures onto SQL tables so developers can create objects with typed properties, nested lists and class semantics, fetch any item by a path like /Customers/cust001/Addresses/addr001, and search or scale to millions of entries without writing raw SQL. The module keeps the underlying tables human readable so you can still use standard database tools, and it preserves object behavior including class name and inheritance when objects are retrieved. It is useful when you want an object-oriented view of data backed by a proven relational engine. Note that destructive operations such as deleting objects or dropping placeholders can irreversibly remove large branches or tables, so care is required.

IO::Tty is a low-level Perl helper for creating and manipulating pseudo-terminals, chiefly used behind the scenes by IO::Pty and the Expect ecosystem and normally only needed if you want to import pty-related constants directly. It targets modern POSIX systems and supports Windows only under Cygwin, but pty behavior is very platform dependent so the module documents a number of system quirks such as inconsistent EOF reporting on some BSDs and Solaris and a known hang on long non-raw writes under Cygwin. Recent maintenance fixed a slave file descriptor leak, corrected raw-mode flag handling on BSD and macOS, and improved portability and CI testing across FreeBSD, OpenBSD and NetBSD. In practice use IO::Pty for everyday pty allocation and rely on IO::Tty only when you need the low-level constants or are diagnosing platform-specific issues.

Net::Ident is a compact Perl module for performing RFC1413 ident lookups to ask the remote end of a TCP connection which user or ID is associated with that socket, useful when a server wants to map incoming connections to remote usernames but only when the remote host runs an ident daemon. It offers a simple synchronous interface as callable functions or optional FileHandle and Apache::Connection methods, plus an asynchronous object-oriented API for integrating with select-based event loops, and in scalar context returns the remote ID or undef while array context yields the ID, reported OS or error tag, and an error message. The module works with either a live socket or packed sockaddr addresses, does not use alarm for timeouts, and keeps error details available from the object when lookups fail. Recent maintenance and releases improved portability and robustness across platforms by fixing sysread edge cases on Windows and Solaris, added comprehensive tests and modern CI, and tightened metadata and minimum Perl version checks. If you need to try to identify remote users at the TCP level and accept that ident information may be unavailable or privacy-masked, Net::Ident is a straightforward, well maintained choice.

Regexp::Parser turns Perl regular expressions into a traversable object tree so you can analyze, transform, validate, or rebuild regexes programmatically. It understands modern Perl regex features including named captures and backreferences, recursive patterns, possessive quantifiers, backtracking control verbs, Unicode properties and a range of newer escapes and boundary forms, and it can produce both a human-readable visual string and a real qr// Regexp object from the tree. Use it by creating a parser, supplying a regex (optionally with pre-set flags), then either iterate nodes as they are parsed with next, build and walk the full tree with parse and walker, or query captures, error codes and messages via errmsg/errnum and the module’s RPe_* constants. The module is extensible via handler subclasses for things like optimizers or explainers, and recent releases added definition-only groups (?(DEFINE)...) and named-capture conditions plus other modern syntax and maintenance fixes. Note that this parses regex text rather than full Perl code so variable interpolation quirks apply when you pass single-quoted strings.

Safe::Hole provides a controlled way for code running in a Safe sandbox to invoke subs and object methods back in the original main namespace, effectively creating a deliberate escape hatch so sandboxed code can use trusted routines or objects without running them inside the Safe compartment itself. You can call a code reference through the hole or create wrapper objects so that method calls are dispatched outside the sandbox, and the module can optionally restore aspects of the calling environment such as the opcode mask, %INC and @INC. Use is simple: new constructs a hole, call invokes a code ref through it, and wrap produces callable wrappers for subs or objects. The module warns that you must not share the Safe::Hole object into the Safe compartment itself because that defeats the sandbox, and it includes fixes to catch and rethrow exceptions correctly and to preserve environment state. Safe::Hole is useful when you need sandboxed code to reach back to trusted code while keeping most sandbox restrictions in place, but it should be used with care because it deliberately bridges those restrictions.

XML::Parser is a long‑standing Perl interface for reading and validating XML that wraps the fast Expat library and gives you multiple convenient ways to work with XML: you can parse a complete string or file, feed it an open handle or stream documents incrementally with a non‑blocking parser, and choose from built‑in "styles" that either call your subs for each element, build a Tree or Objects representation, print a Debug outline, or drive a Stream-style callback API. The module is driven by event handlers (Start, End, Char, etc.) that receive the underlying Expat parser object and let you handle markup, CDATA, DTD and external entities, with sensible defaults that use either file access or LWP for external URIs and options to control namespaces, encodings and entity expansion. Error handling is exception‑based and can include contextual lines around parse errors when you enable ErrorContext, and the Tree/Objects styles return convenient in‑memory structures if you prefer to work with a parsed representation instead of callbacks. The latest releases modernize compatibility and safety: recent fixes restrict the Subs style to package‑local subs to avoid accidental dispatch into inherited methods and the distribution now targets Perl 5.8 and later while improving robustness and encoding support. If you need a mature, flexible Perl parser that exposes low‑level Expat features but adds higher‑level styles and convenient error and encoding handling, XML::Parser is a solid choice.

App::OATH is a compact command-line tool that implements OATH TOTP two-factor authentication in Perl and can be used with the same tokens as Google Authenticator. It stores multiple tokens in an encrypted JSON file (default ~/.oath.json) and provides commands to add entries by identifier:secret or otpauth URL, list and search keys, and display current one‑time codes or render them as QR codes. Tokens are encrypted on disk while identifiers remain readable, so it protects against casual inspection but is not a full security hardening solution. The module includes a lock file to avoid race conditions, cross-platform home‑directory and password input support, and a recent option to show raw OATH codes to aid migration.

DBD::Oracle is the official Oracle database driver for Perl's DBI that lets Perl programs connect to and work with Oracle databases through the Oracle Call Interface. It provides a full set of DBI-compatible operations so you can open connections with DSNs or TNS/EZCONNECT strings, execute SQL and PL/SQL, bind scalars and arrays, return and fetch cursors, and handle large objects with several fetch and write strategies. The driver also exposes many Oracle-specific features such as DRCP connection pooling, TAF failover callbacks, scrollable cursors, object and collection types, and TLS support configured at the Oracle client level, plus Unicode handling when the client and database are configured for AL32UTF8. You do need matching Oracle client libraries and to set ORACLE_HOME or TNS_ADMIN appropriately, and DBD::Oracle requires Oracle client support roughly 9.2 or later, so if you are building Perl applications that need robust, production-grade access to Oracle this mature and feature-rich driver is highly relevant.

Medusa is a lightweight Perl module that adds automatic auditing to subroutines by tagging them with the :Audit attribute. When a tagged routine runs, Medusa records the call with its arguments and the return values, which helps with debugging, compliance tracking, and understanding data flow without changing your business logic. You can control where and how messages are written by setting import options such as LOG_LEVEL and LOG_FILE or by supplying a custom logger class that provides a constructor and error/info/debug methods. This is the initial 0.01 release and provides a simple, non‑intrusive way to instrument your code.

DBIx::SearchBuilder is a mature, database-agnostic toolkit that gives Perl developers a simple object-oriented layer on top of DBI for building SELECT queries, iterating result rows as objects, and performing common tasks like joins, paging, counts and grouped queries. You typically create a subclass for each table and a matching DBIx::SearchBuilder::Record subclass to represent rows, override NewItem and initialize the table and Handle, and then use the collection methods to add limits, orderings, columns and aliases instead of writing raw SQL. It supports bind variables, query hints, left and expression joins, distinct queries and convenient debugging via BuildSelectQuery, and it now avoids fetching columns marked lazy_load by default to reduce work and improve performance. If you need a lighter, flexible abstraction over DBI for complex queries and result-object handling without adopting a full ORM, DBIx::SearchBuilder is a practical choice.