CPANscan

File::Raw is a performance-focused Perl module that replaces many common file and directory operations with direct system calls to make reading, writing, copying and metadata queries much faster than PerlIO. It exposes convenient functions like file_slurp/file_spew and file_append, memory-efficient line operations including a fast callback-based each_line and a lines iterator, zero-copy reads via file_mmap_open, atomic_spew for safe writes, and native-optimized copy/move operations. The module also provides stat with an internal cache to avoid repeated syscalls, a full suite of file tests and path helpers, directory utilities and recursive mkpath/rm_rf, plus hooks so you can transform data on read or write and an XS API so other C extensions can register hooks without Perl callback overhead. Functions are imported with a file_ prefix for low-overhead calls. If you need faster IO on large files, streaming line processing, memory mapping, atomic updates or C-level integration, File::Raw is directly relevant, and recent releases improved portability and added path and recursive directory helpers while fixing build issues on Solaris and Windows; remember to call clear_stat_cache when external processes may have modified files.

Music::ScaleNote is a small utility for moving a note around within a musical scale and returning the resulting note as a Music::Note object. You give it a scale start, a named scale and a starting note and it computes the note a given number of scale steps away with get_offset or a given number of chromatic half steps with step. It understands common note formats such as ISO names and MIDI numbers and can be told to prefer flats or sharps. This makes it handy for tasks like programmatic transposition, algorithmic composition, or generating scale-based melodies without dealing with interval math yourself.

Mojolicious is a modern real-time web framework for Perl that provides a batteries-included toolkit for building web apps and APIs quickly. It offers a simple RESTful router, a built-in nonblocking web server and user agent, a Perl-friendly templating system, content negotiation, session and cookie handling, form validation, static file serving, hooks and helpers for extending behavior, and a plugin and command system for reusable features. The framework includes testing support, strong Unicode handling, and thorough guides to help you prototype or scale production applications. Be aware that the default secret passphrase is intentionally weak and should be replaced for secure signed cookies and sessions. If you develop web software in Perl and want a full-featured, extensible framework with real-time capabilities, Mojolicious is a good fit.

HTTP::Tinyish is a lightweight compatibility wrapper that gives you the HTTP::Tiny API while transparently using whatever HTTP client is available on the system—LWP, HTTP::Tiny, curl or wget—so your code can perform get, post, put, delete, patch, request and mirror operations even in restrictive environments. It auto-selects backends and detects HTTPS support, translates common options like timeouts, redirects, headers and user agent, and is especially handy for tooling that must fetch CPAN modules or other resources on machines where the built-in Perl HTTP stack lacks SSL or where only command-line clients are present. The module documents backend-specific caveats such as LWP needing LWP::Protocol::https for HTTPS and older wget versions not supporting custom methods, and it translates backend behavior into HTTP::Tiny-style responses. Recent updates fixed mirror() for the curl and wget backends so failed downloads no longer leave local files and HTTP error codes are reported correctly.

Rose::DB::Object is a mature, high-performance object-relational mapper for Perl that maps individual database rows to rich Perl objects and gives you metadata-driven control over tables, columns, keys and relationships. You can declare classes manually or let it auto-discover schema information, work with one-to-one, one-to-many and many-to-many relationships, lazy-load columns, inflate and deflate values into convenient Perl types, and use the companion Manager to build complex queries, iterate results efficiently, count, update and delete matching rows. It supports multiple databases through Rose::DB but requires tables to have non-null primary keys, and it is designed to be extensible so you can add custom column types, triggers and primary key generators when needed. The distribution also includes a Loader to auto-generate classes from an existing schema and helpers for cascaded saves and deletes across related objects, all within configurable transactions. Recent updates improve compatibility with newer DBD::Pg behavior and MySQL ONLY_FULL_GROUP_BY settings and modernize internals such as replacing List::MoreUtils with List::Util. If you need a powerful, well-documented ORM with fine-grained metadata control and strong cross-database behavior, Rose::DB::Object is worth evaluating and you can start with Rose::DB::Object::Tutorial for a quick introduction.

Rose::DB is a practical wrapper around DBI that gives you a higher-level way to define and use logical data sources instead of raw DSNs, manage DBI handles, and handle database-specific value parsing and formatting. You register named data sources (by domain and type) or load them from small config files, then instantiate a Rose::DB object to get a driver-specific subclass and a connected DBI handle when you need it. It provides handle lifecycle management with retain/release semantics, simple transaction helpers including a do_transaction block, and vendor-aware conversions for dates, times, booleans, bitfields, intervals, and related types. The module supports common drivers such as PostgreSQL, MySQL/MariaDB, SQLite, Informix, and Oracle and is designed to be subclassed for custom behavior. It is not an ORM, so if you want object-relational mapping use Rose::DB::Object, and be aware of a serialization caveat that requires preloading registered data sources before thawing objects across processes.

RT::Extension::ToggleTheme is a lightweight plugin for Request Tracker 6 that adds a simple light/dark theme toggle to the web interface so users can switch to dark mode for easier nighttime use. The button is shown only to users who have the ModifySelf right and appears in both the main and self-service navigation areas. It performs instant client-side switching by toggling data-bs-theme on the html element and relies on RT 6's native dark-mode styling and icons for a clean, integrated experience. Installation is done via the RT plugin mechanism and requires adding the plugin and refreshing the Mason cache or restarting the webserver. Recent updates include a rewrite to support RT 6 and Bootstrap 5 plus a small fix to avoid a keyboard-shortcuts.js error.

Net::Silverpeak::Orchestrator is a Perl client library for talking to the Silverpeak Orchestrator REST API that makes it easy to script common tasks such as authenticating with an API key or user/password, listing and managing template groups, appliances and appliance groups, address and service groups, domain and application groups, VRF configurations and security policies, BGP and IP SLA data, backups and other Orchestrator resources. The module exposes straightforward create, read, update and delete methods plus helpers for appliance-specific REST calls and handles API endpoint changes introduced in Orchestrator 9.3 while recent updates add appliance REST passthrough methods and compatibility fixes for newer Orchestrator releases. It also includes convenience features like explicit login/logout and automatic logout when the object is destroyed. Be aware of a known Orchestrator server issue on versions before 9.0.4 where API key authentication can return HTTP 500 unless the key has an expiration date set.

Geo::Leaflet is a Perl helper that builds complete Leaflet JavaScript map pages from Perl code, so you can programmatically produce interactive maps without handcrafting the HTML and JS. You create a map object, set its id, center, zoom and dimensions, and then add common map pieces like a tile layer (defaults to OpenStreetMap), markers, custom icons including Font Awesome divIcons, polylines, polygons, rectangles and circles. The module exposes simple constructors that mirror the Leaflet API and then emits the finished HTML and scripts via an html method you can print or embed. It includes sensible defaults for center, zoom and sizing, and uses HTML::Tiny and JSON::XS internally to generate clean output. Use Geo::Leaflet when you need to generate web-ready interactive maps from Perl quickly and with minimal JavaScript knowledge.

File::Unpack2 is a Perl library and command line tool that detects and recursively unpacks a wide range of archive and packed file formats by analyzing MIME types instead of trusting file extensions. It supports tar, zip, gz, bz2, lzma, 7z, rar, rpm, deb, cab, cpio, iso, pdf, ODF and many more, can descend into nested or multiply wrapped archives to expose all payload files, and lets you add external shell-script helpers to handle new mime types. The module combines libmagic and shared-mime-info to provide multi-level MIME recognition so common cases like tar+gzip are handled efficiently, and it produces a JSON logfile that records every unpacked item and related metadata. You can control destination directory, file size limits, symlink behavior, file permissions and other safety guards, and the recent 1.1 release fixed cleanup of temporary archives created during unpacking. The author notes the MIME-detection code is somewhat complex and the built-in helper set is not exhaustive, but overall File::Unpack2 is a robust solution when you need content-aware, recursive extraction rather than simple suffix-based unpacking.

Business::ISBN::Data is a data-only companion for Business::ISBN that supplies the official ISBN range information used to validate and decode group and publisher ranges. You normally do not load it yourself because Business::ISBN will auto-load it, and it requires Business::ISBN 3.005 or later to accommodate fixes for ISBN-13 prefixes. The module ships a copy of the ISBN RangeMessage.xml and also contains embedded fallback data if that file is missing, and you can point the module at an alternate RangeMessage.xml by setting the ISBN_RANGE_MESSAGE environment variable or by placing the file in the current working directory so bundled apps can find it. If you need newer ranges you can include an updated RangeMessage.xml in your installation or regenerate the default data with the provided script, and the code and data are maintained on GitHub for contributions and updates.

Minima is a lightweight PSGI web framework that uses Perl's new native class system to give you a minimal, fast foundation for web applications. It follows an MVC-like approach without enforcing one, so controllers can use Plack request and response objects directly and you can pick any view system, with built-in support for Template Toolkit if you want it. Routes are defined in a simple routes.map file and the distribution includes a command line helper to create and manage projects and an easy init entry point for Plack. Recent updates in v0.8.0 add convenient route-level redirect commands, session-backed flash messages for one-time notices, and an API to access the configured not_found route, making common tasks like redirects and transient user messages simpler to implement. Minima is best for developers who want a modern, unobtrusive Perl framework that provides the essentials without getting in the way.

DateTime::Lite is a lightweight, low-dependency drop-in replacement for DateTime that gives you the same familiar API for creating, formatting, comparing, and doing calendar arithmetic with datetimes while using less memory and loading faster in short-lived scripts. It provides accurate IANA timezone handling by reading TZif binaries compiled with the official zic tool and ships a compact SQLite timezone database with options for coordinate-based lookup and BCP47 -u-tz- locale inference, full Unicode CLDR locale support via DateTime::Locale::FromCLDR, and XS-accelerated math for the hot calendar paths. The module aims to behave like DateTime so existing code usually works unchanged, avoids dying on normal error paths by returning exception objects, and includes a pure-Perl fallback for environments without a C compiler. If you need fast startup, modern timezone rules, flexible locale-driven time zone selection, or a smaller dependency footprint for command line tools and batch jobs, DateTime::Lite is likely relevant. The recent v0.6.6 release tightened the XSLoader fallback and fixed several issues in the pure-Perl fallback so the module now degrades cleanly on platforms with older compilers and the pure-Perl path is more complete and robust.

Sys::GetRandom::PP is a pure-Perl wrapper around the kernel getrandom(2) call that lets Perl code obtain random bytes directly from the kernel RNG without opening /dev/urandom or loading a C extension. It exports getrandom, which fills a scalar with up to a requested number of bytes and returns the number generated or undef on error, and random_bytes, which returns a string of 0 to 256 random bytes, along with the GRND_RANDOM and GRND_NONBLOCK flags to select /dev/random or nonblocking behavior. By default it behaves like reading /dev/urandom and may block until the kernel RNG is initialized, larger reads can be interrupted by signals, and the wrapper enforces the 256 byte limit for the convenience function. It mirrors the interface of the XS Sys::GetRandom module but is implemented in pure Perl for easier installation and works on Linux and FreeBSD.

Params::SomeUtil is a compact toolkit of importable functions for robustly validating arguments and data in Perl programs, aimed at the edges of your API where untrusted input arrives. You pick the small checks you need, such as _SCALAR, _ARRAY, _HASH, _INSTANCE, _CLASS, _NUMBER, _CODELIKE, _REGEX, _HANDLE and _DRIVER, and each returns the validated value on success or undef on failure so you can fail fast and clearly. The checks are conservative, well documented and heavily tested so they behave predictably with odd or malicious inputs. This distribution is a maintained fork of Params::Util that fixes several long-standing bugs and preserves the original XS behaviour, so nothing is exported by default and you must explicitly request symbols. Note that the XS components are unchanged from the upstream release which can mean a C compiler is needed to install on some systems.

XS::JIT is a lightweight runtime JIT compiler for embedding C/XS code into Perl programs that need to generate and load C code on the fly. It takes your C source that uses the Perl C API, compiles it with a direct compiler invocation, and installs the resulting functions into Perl namespaces with optional caching to avoid recompilation. Compared with Inline::C it avoids heavy parsing and xsubpp, which makes initial compilation and subsequent loads faster, and it provides a C API and helper methods so other XS modules or build systems can integrate with it. The module supports both simple SV* wrapper-style functions and XS-native functions for maximum performance, supplies convenience macros and Inline::C compatibility shims, and returns the necessary include and linker flags for Makefile.PL. Use XS::JIT when you want fast, minimal-overhead runtime compilation of generated C code; if you need the broader feature set of Inline::C you may prefer that more feature-rich alternative.

Game::HexDescribe is a Mojolicious::Lite web application that turns hex maps into coherent, table-driven descriptions by applying recursive random tables that respect neighboring tiles so features like rivers and forests can span multiple hexes. It integrates with Text Mapper to generate or render maps and can accept built-in or external rule tables, pasted table text, or a pure text input mode for use as a general random text generator. The app is configurable via a hex-describe.conf file, exposes simple URLs for editing, generating random maps, rendering descriptions as HTML or Markdown, and running without a map, and it can optionally include or omit images and embedded SVG links so map tiles and descriptions stay linked. Command line usage is supported for automated workflows and the distribution includes several ready-made table sets such as Schroeder, Seckler, Strom, Johnston, and Traveller. Recent changes add a "closest" keyword, tweak the behavior of the "same" rule, extend arithmetic operators, and provide an option to hide the map in output, making it more flexible for game designers and worldbuilders who want automated, spatially consistent prose rather than isolated random entries.

Game::TextMapper turns a simple, human-readable text description of a hex grid into a fully editable SVG map, making it easy to design landscapes, settlements, roads, rivers, and decorative shapes for role playing or worldbuilding. You define hex types, SVG attributes, labels, icons or arbitrary SVG fragments and even closed paths for large areas, and the tool supports includes, reusable libraries, transparency, URL-linked labels, and multiple map-generation algorithms and style libraries so you can generate random maps or import curated icon sets. It works from the web or the command line and produces SVG you can view in a browser or refine in Inkscape, with configuration options for libraries and logging. Recent updates added Gazetteer icons and improved parsing of Traveller UWP data, making it handier for genre-specific map types.

Game::FaceGenerator is a lightweight Mojolicious::Lite web application that builds faces by compositing random image elements from a configurable contributions directory, offering both a fun face generator and a simple browser-based editor for artists to nudge parts into place. It reads a face-generator.conf file to control log level, file locations, per-user background images, and a secret used to protect login cookies, and it supports per-artist settings such as disabling horizontal flipping for asymmetric elements. The app is easy to run during development or deploy in production and is useful if you want to quickly prototype or host a collaborative image-element face generator. Recent releases add a published "random" face type for every artist to make unpredictable results simpler to obtain.

App::Test::Generator is a test-generation toolkit for Perl that helps you add thorough black‑box checks to your modules by automatically creating Test::Most-based harnesses from simple schema files. You describe a routine in YAML or let the included SchemaExtractor infer a schema from source and the generator will produce randomized fuzz cases, deterministic edge cases for declared min/max constraints, optional static corpus tests, and property-based transforms that use Test::LectroTest for heavy-duty invariants. It also ties into a mutation-testing pipeline so surviving mutants can drive new schema or TODO stubs, produces LCSAJ path metrics and a HTML dashboard for CI, and is designed to run reproducibly with configurable seeds and iterations so it fits into make test and GitHub Actions workflows. Recent releases fixed several generator bugs that could make generated tests trivially pass or misname builtins, improved the mutation-to-test pipeline and dashboard portability, and added a much more comprehensive internal test suite so the generated harnesses and mutation guidance are more reliable. If you maintain a CPAN distribution or want automated, schema-driven fuzzing and mutation-guided test improvement, this module is directly relevant.

Radamsa provides Perl bindings to the Radamsa mutational fuzzer so you can quickly generate mutated variants of byte strings for fuzz testing and input generation. It offers a simple functional interface via mutate($input, %options) and a stateful object interface via Radamsa->new(...)->mutate(...), with configurable options such as a numeric seed and maximum output length. The CPAN package ships a vendored C implementation so you can install without fetching external toolchains. It is useful for producing malformed inputs to test parsers, protocols, file handlers and other code that must tolerate unexpected data. Be aware that Radamsa keeps internal state between calls so a fixed seed influences output but repeated calls in the same process are not guaranteed to produce identical byte-for-byte results. The bundled Radamsa source is included under the MIT license.

Log::Log4perl::Config::YamlConfigurator is a small adaptor for Log::Log4perl that lets you express loggers, appenders and layouts in YAML and have them turned into a live Log::Log4perl configuration. You can pass either a Perl data structure produced by YAML::PP::Load or the raw YAML text to the constructor, call parse or hand the configurator to Log::Log4perl->init, and it will set up the requested loggers; it also lets you instantiate an appender by name even if it is not attached to a logger. The module focuses on mapping YAML configuration to Log::Log4perl objects and does not yet support variable substitution. Recent updates moved to YAML::PP and now load Log::Log4perl::Config and YAML::PP lazily to reduce startup cost. The module is authored by Sven Willenbuecher and is distributed under the same license as Perl 5.

Net::CalDAVTalk (v0.16) is a Perl client library that talks to CalDAV calendar servers and presents calendars and events through a simple JSON-style interface, building on Net::DAVTalk and including CalDAV and Cyrus-specific XML namespaces. It is the FastMail implementation used by tests and mail services, and it provides high-level operations to list, create, update and delete calendars and events, fetch event links or full event data, perform sync-token based incremental syncs, run free/busy queries, move or annotate events, and export calendar data as iCalendar; it also caches timezones and offers a pluggable logger callback. The module delegates iCalendar↔JSCalendar conversion to Text::JSCalendar and supports useful CalDAV features such as multi-get and sync reporting, and the recent 0.16 release adds support for sending Schedule-Reply: false via the _no_schedule flag to suppress iTIP scheduling replies while 0.15 fixed a serious UpdateEvent merge bug. Net::CalDAVTalk is practical for integrating CalDAV into Perl services, though it was written around an early FastMail API and some extended properties are not fully parsed.

Dist::Zilla::Plugin::SigStore::SignRelease is a Dist::Zilla plugin that automates signing your CPAN distribution with SigStore via the cosign tool and can attach and upload the resulting signature bundle to CPAN alongside your tarball. It runs automatically after a release, lets you choose the signature file extension and whether the bundle is uploaded, and can auto-answer cosign prompts for unattended CI-friendly operation. You must have the cosign application installed to use it, and note that PAUSE and CPAN clients do not currently perform sigstore verification automatically so consumers will need to verify signatures manually with cosign if desired.

Permute::Unnamed is a tiny Perl utility for producing the Cartesian product of multiple input lists and returning every combination as array references. It offers a minimal, unnamed API that is easier to use when you only need raw tuples rather than named parameters, so it is handy for generating parameter grids, test cases, or any situation where you must iterate all possible pairings or combinations of list elements. The module is lightweight, complements modules like Set::CrossProduct and Permute::Named, and is available on MetaCPAN from the author perlancar.

JSON::LINQ provides a fluent, LINQ-style query interface for JSON, newline-delimited JSON (JSONL) and LTSV files so you can filter, project, group, sort, join and aggregate data with readable method chaining instead of hand-rolled loops. It supports streaming access for JSONL and LTSV with O(1) memory usage, offers a small DSL for simple key/value filters, and implements about 65 LINQ methods including JSON and LTSV I/O helpers so you can read files, join against lookup tables, and write results back as JSON, JSONL or LTSV. The module is pure Perl with a built-in JSON encoder/decoder so it has no XS or CPAN dependencies and runs even on very old Perls. Common uses include processing large log streams, transforming JSON data sets, joining JSON records to small LTSV lookup tables, and performing aggregations and sorts in concise code. Be aware of a few documented limitations of the bundled JSON parser such as lack of surrogate pair support, potential infinite recursion when encoding circular references, and an iterator design quirk where a top-level JSON null becomes indistinguishable from end-of-sequence. If you need a compact, dependency-free way to query and stream JSON and LTSV data inside Perl scripts, JSON::LINQ is a practical choice.

DateTime::Format::RelativeTime is a Perl port of the JavaScript Intl.RelativeTimeFormat API that produces localized human‑friendly relative time strings like "in 3 days" or "yesterday". It uses Unicode CLDR data via Locale::Unicode::Data and Locale::Intl to support locales, numbering systems, styles (long, short, narrow) and numeric modes (always or auto). You can format simple value/unit pairs or pass one or two DateTime or DateTime::Lite objects to have the module compute the largest time difference, and it offers both format and formatToParts for full strings or componentized output. The module mirrors browser behavior so results may vary by locale and can include non‑breaking spaces or bidi markers, and it formats numeric output with up to 15 significant digits. Because initialization performs CLDR lookups you should create and cache a formatter for reuse rather than instantiating one per call. It requires Perl 5.10.1 or newer and the latest release updates a dependency to match the current Locale::Unicode::Data.

EV::Kafka is a high-performance asynchronous Kafka client for Perl that plugs into the EV event loop and implements the Kafka binary protocol in XS so you do not need librdkafka. It exposes a low-level EV::Kafka::Conn for single-broker protocol operations and a higher-level EV::Kafka::Client for cluster management, metadata discovery, producer and consumer workflows including key-based partitioning, acks, idempotent and transactional production, consumer groups, manual assignment, and offset management. The module supports pipelined requests, optional compression and TLS, SASL PLAIN and SCRAM authentication, and integrates with AnyEvent when EV is used as the backend. Note that it treats all message data as raw bytes so you must encode UTF-8 yourself, DNS lookups for hostnames are blocking which can stall the EV loop, and it does not provide GSSAPI, OAUTHBEARER or the Kafka flexible APIs. Choose EV::Kafka when you need low-latency, high-throughput Kafka or Redpanda access from Perl and want a direct, protocol-level client with advanced producer and consumer features.

RT::Extension::HistoryFilter is a lightweight plugin for Best Practical's Request Tracker that trims the ticket display history to only the transaction types you care about, making ticket pages easier to scan by hiding routine or verbose events. Administrators pick which transaction types are shown via configuration and user preferences and the module ships with sensible defaults such as create, correspond and comment. The detailed history view is left intact so no data is lost, and the extension is an enhanced take on RT::Extension::BriefHistory. Installation is simple for modern RT releases by enabling the plugin and clearing Mason cache, though very old RT 4.2.3 and earlier installations require an additional patch.

RT-Extension-MandatoryOnTransition is a plugin for Request Tracker that prevents tickets from being moved to or from specified statuses or queues until required core fields, custom fields, or roles have been set, so you can make sure items are resolved only after required information like a reply, time worked, a resolution field, or a particular role is assigned. It integrates with RT lifecycles and is configured in RT_SiteConfig.pm using the %MandatoryOnTransition structure to declare which fields are mandatory for particular status or queue transitions, and it supports value checks (must_be and must_not_be) and optional group membership checks for role assignments. The extension works with RT 6 and has a 0.x branch for RT 5, it exposes only the needed fields on the update page to make completion easier and enforces standard RT validation patterns for custom fields. Note that enforcement is not available on every update path yet, for example SelfService and some quick-create pages are not supported, and multi-valued custom fields have limited handling for must_be and must_not_be rules.