CPANscan

Plack is a lightweight Perl toolkit that implements the PSGI specification and acts as the glue between web applications, frameworks and web servers. It gives you server adapters so the same app can run under CGI, FastCGI, Apache or standalone servers, a loader and plackup command to run .psgi application files, a middleware system and a small builder DSL to stack common features like logging, static file serving and compression, and convenient Request and Response wrappers to work with the PSGI environment. Plack also includes testing helpers to exercise applications with real HTTP requests without starting external servers which makes development and debugging easier. If you build or deploy Perl web apps or frameworks Plack lets you mix and match servers and middleware and standardizes how apps are run and tested. Note that the project recently deprecated Plack::Middleware::XSendfile due to security design concerns so check the changelog for migration guidance.

Win32::EventLog lets Perl programs interact with Windows Event Logs so you can open, read, back up, clear and write event records from scripts. It exposes an EventLog object with methods to connect to local or remote logs, read entries sequentially or by offset, back up or clear a log and report new events, and it provides a helper to format an entry's message text. The module understands Windows concepts like event type, category, event ID, raw data and insertion strings and exports useful constants to simplify code. It is a practical tool for Windows system administrators and developers who need to automate log collection, auditing or alerting with Perl. Recent fixes improved read reliability by correcting a skipped-record bug in sequential reads and by refactoring read caching for seek mode.

Win32::NetAdmin is a Perl module for administering Windows network accounts and groups from scripts, letting you create, delete and modify users and groups, check membership, change passwords, and enumerate domain controllers, servers, transports, logged-on users and local drives. Most functions accept an optional server name so you can target the local machine or a remote host, and they return false on failure with Win32::NetAdmin::GetError() available to retrieve the Windows error code. This module is useful for automating Windows account and group management but many operations require administrative privileges on the target machine. The project is actively maintained and the latest release fixes a memory leak and improves build and test reliability on Windows Server.

Win32 is the standard Perl interface to many Windows API routines, giving Perl scripts easy access to Windows-specific functionality without writing C or XS code. It wraps common tasks such as creating and copying files and directories, converting and querying path names (long, short, ANSI and Unicode), getting OS and filesystem details, reading process and thread IDs, inspecting privileges and administrative status, working with console code pages and system metrics, generating GUIDs, initiating shutdowns, showing message boxes and even a simple HTTP file downloader. The module is useful whenever you need to query or control aspects of the host Windows environment from Perl, and it includes some higher-level helpers like GetOSName/GetOSDisplayName and GetFolderPath. Be aware that path-related functions may return Unicode or ANSI names and that short (8.3) path support is system- and volume-dependent so results can vary on modern Windows, and a few legacy entry points are deprecated. Recent updates modernize packaging and documentation and improve detection of newer Windows releases and CPU architectures.

Spreadsheet::Edit is a Perl tool for loading, inspecting, transforming and saving tabular data from CSV files or common spreadsheet formats with a friendly, scriptable API. It gives you a sheet object and a functional interface where each row behaves like both an array and a hash so you can refer to columns by index, letter, title or user-created alias. Typical uses include scanning or applying a block to every data row, random access, inserting, deleting, moving or splitting columns, sorting rows, transposing tables, and writing back to CSV or spreadsheet files. For convenience it can tie package variables to columns so you can write mail‑merge or row-oriented code that reads and writes column variables directly. The module also auto-detects title rows, CSV encodings and column formats and recent improvements focus on safer CSV handling and format detection so values like leading-zero zip codes survive round trips to spreadsheet formats. One practical caveat is that reading non-CSV spreadsheets relies on external tools and can fail if LibreOffice/OpenOffice is running, so CSV input is the most robust option.

Test::Mockingbird is a Perl testing utility that makes it simple to replace and observe parts of your code so you can write focused unit tests. It provides mocking to swap in custom implementations, spies that record every call and its arguments, dependency injection to substitute collaborators, and scoped guards that automatically restore mocks when they go out of scope. Handy helpers let you make a method always return a value, throw an exception, yield a sequence of values, or act only once, and there are unmock, restore, and restore_all routines to clean up test state. Non‑intrusive diagnostics give a readable and structured view of active mock layers and where they were installed to help debug complex test setups. In the recent 0.09 release mock_scoped was fixed so it no longer creates duplicate diagnostic entries and now supports multi‑method guards that restore several mocks atomically, making scoped mocking more reliable and convenient.

IRI is a Perl module that implements Internationalized Resource Identifiers (IRIs) as defined by RFC 3987 and makes it easy to parse, serialize, inspect and resolve IRIs in your code. It gives you an object you can query for scheme, host, port, user, path, query and fragment, resolve relative IRIs against a base, obtain or set query form data, and produce absolute or relative string forms. The module can defer parsing until a component is actually accessed to save work on simple use cases, and it includes helpers like query_form and set_query_param for manipulating query data and rel to compute a relative IRI. Use IRI when you need robust handling of non-ASCII URLs, link resolution, or IRI normalization in web applications or tools. Recent maintenance updates fixed a trailing-newline parsing bug and corrected packaging metadata, and earlier releases added lazy parsing and relative-IRI support.

Graphics::Framebuffer is a Perl library for drawing directly to a Linux console framebuffer, giving you pixel plotting, lines, shapes, gradients, image blitting, TrueType text and simple animation without the overhead of X. Its methods take hashref parameters and cover everything from single-pixel plotting and clipping to filled polygons, rotated and scaled blits, color conversions and basic mouse polling, while optional Imager and Inline::C acceleration speed up heavy operations. The module runs in exclusive graphics mode on framebuffer devices and will fall back to an emulated in-memory screen for development, but it will not work inside X/Wayland and prefers open source drivers such as Nouveau rather than proprietary DRM drivers. It is CPU bound in pure Perl so 24/32 bit modes and enabling acceleration improve performance, and the author documents caveats for functions like flood fill and TTF rendering. If you need simple, low-level console graphics for embedded Linux, media players or kiosks, this module is a practical, well documented choice.

Router::Ragel is a high-performance URL router that compiles route patterns into a single Ragel-generated finite state machine and emits C via Inline::C so matching is a fixed-cost DFA walk rather than a per-route regex scan. It supports static segments, named placeholders, typed constraints and inline placeholders inside segments, and you can use a function form of match to minimize call overhead. You must call compile to build and dlopen the generated machine before matching, and for best deployment behavior you should compile in the parent process or warm the Inline::C cache to avoid per-worker compilation. The router matches byte strings exactly and requires patterns to start with "/", it treats UTF-8 strings as bytes, adding routes after compile invalidates the compiled matcher and requires recompilation, and pattern validation is strict. Recent 0.02 adds typed and inline placeholders and tighter compile-time validation.

Attean is a Perl Semantic Web framework that provides a unified API for parsing, storing, querying, and serializing RDF and SPARQL data. It is plugin driven so you can pick different store, parser, and serializer implementations by name, filename extension, or media type, and it includes a ready-to-use in-memory store and temporary models for quick work. The library handles streaming iterators of triples and quads, can attach graph names to triples, and evaluates SPARQL algebra against models to return bindings or result sets. For web services it can negotiate content types with HTTP::Negotiate and produce Accept header strings that reflect available parsers. Developers can also register global SPARQL functions, functional forms, aggregates, and datatype roles to extend evaluation behavior. If you need to work with RDF data in Perl, convert between formats, store quads, or run SPARQL queries, Attean gives a cohesive and extensible toolkit.

CPAN::Maker is a command-line tool that automates turning a Perl project into a CPAN distribution using a YAML "buildspec" file. It can scan your code for module dependencies, generate a Makefile.PL with META information and dependency lists, collect modules, scripts, tests and extra files into a tarball, and call a provided bash helper to complete the build, while offering options to include or omit core modules, add version constraints, and preserve the generated Makefile or skip tests via environment variables. The tool includes a validate command that checks buildspec.yml against a JSON schema so you can catch errors early in CI and a write-makefile path that emits Makefile.PL when you want to inspect or modify it manually. Recent 1.9.0 improvements refactor autoconf handling into a CPAN::Maker::Bootstrapper, add a formal buildspec schema and polish CLI behavior to make automated, repeatable builds and validation more reliable.

File::Process is a small Perl utility that removes the repetitive open/read/close boilerplate when you need to read and transform text files. It provides a single exported function process_file that accepts a filename or filehandle and a set of options and runs a sequence of customizable hooks — pre, next_line, filter, process and post — so you can chomp, trim, skip blank or commented lines, merge lines, or inject custom per-line logic without reimplementing file-handling each time. The function returns the accumulated lines (or a merged scalar) plus any metadata collected during processing and includes convenience support and examples for common tasks such as CSV or JSON handling with Text::CSV_XS and decode_json. It is aimed at moderately sized files because it typically accumulates lines in memory and the hook-based approach is not as fast as raw slurping for very large data sets. This package ships as the initial 1.0.0 release and includes a companion File::Process::Utils module plus basic tests and build files.

File::Raw::Base64 is a compact plugin for File::Raw that registers two filters, "base64" and "base64url", so you can encode or decode Base64 directly when using file_slurp and file_spew. It supports common options such as wrap width and end-of-line style, URL-safe alphabet and optional padding, and a PEM mode that strips or emits BEGIN/END markers with a configurable label. Decoders tolerate missing padding by default and can be made strict to reject unexpected bytes, and the module performs in-memory, per-call conversions rather than streaming, which matches the typical single-call file I/O use case. Use it when you want convenient, configurable Base64 handling integrated with File::Raw, including PEM and JWT-style variants.

File::Raw::Separated is a compact, high-performance CSV and TSV parser that plugs into the File::Raw I/O layer to give you both simple in-memory parsing and a streaming API for files larger than RAM. It exports parse_buf/parse_buf_each/parse_stream (and dialect-pinned csv_* and tsv_* variants) as file_<name> functions when imported, and also registers "csv" and "tsv" plugins so you can call file_slurp with plugin => 'csv' or 'tsv' to get an array of rows or an array of hashes when header mode is enabled. You can control separators, quoting, backslash escapes, line ending handling, trimming, empty-field semantics, strictness on malformed input, and a per-field max byte length, and the stream reader reads in fixed-size chunks so memory use is bounded by the read buffer plus the largest field. Callback-based APIs reuse a single arrayref per row for efficiency so copy rows if you need to keep them, and strict mode will croak with a helpful byte-offset on malformed input. The module is a first release and currently only implements the read side and File::Raw plugin registration while write/record phases are planned for future versions.

RTIR-Extension-MISP is a plugin for RTIR that connects your incident response system to a MISP threat‑intelligence instance so you can ingest events, view event details on incident pages, and create or update MISP events directly from RTIR tickets. After configuring the MISP URL and API key it adds a MISP feed to the External Feeds page, a MISP Event Details portlet on incidents when a MISP ID is present, and Actions to create or update events so incident data and indicators can be pushed to or pulled from MISP. The extension supports custom field groupings for showing MISP IDs and includes Mason callbacks to let you tailor what data is sent and how results are handled. It is written for RTIR 5.0 and requires the usual plugin installation and configuration in RT_SiteConfig.pm. A recent release added BeforeMISPSync and AfterMISPSync callbacks to make customization of the create/update sync easier without modifying the extension code.

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.

RT::Extension::AttachmentViewer enhances the attachment dropzone in Request Tracker (RT) by letting users click file thumbnails to open a modal viewer so images, PDFs, audio, HTML and plain text can be inspected inline without leaving the ticket. Other file types continue to open using the browser's default behavior. It installs as a simple RT plugin and supports RT 5 and RT 6, making it a handy add-on for support and ticketing workflows where quickly previewing attachments saves time. Recent updates focused on adding RT5 compatibility and tightening security while improving modal behavior.

MARC::Validator is a small Perl utility for developers and library technologists that discovers and lists installed MARC validation plugins so you can build or run checks on MARC bibliographic records. It uses Module::Pluggable to find modules named MARC::Validator::Plugin::* and exposes a single plugins method that returns the available plugin module names, making it easy to assemble a modular validation workflow or to display which rule sets are present in an environment. If you work with MARC records and want a lightweight, pluggable way to manage field-level validators this module is directly relevant.

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.