CPANscan

Graphics::Framebuffer is a Perl library for drawing directly to a Linux console framebuffer, letting you plot pixels and draw lines, shapes, gradients, rounded boxes, Bezier curves, text with TrueType, load and blit images and even play animations without X. It maps the framebuffer into memory and exposes a straightforward API where most methods take a hash reference for parameters so you can control clipping, drawing modes (XOR, mask, alpha, add, multiply and more), color handling, and blit transforms such as rotate, scale and merge. The module supports 32/24/16 bit framebuffers and provides an emulation mode for offscreen development or testing on systems without framebuffer devices, and many operations can be accelerated via Imager or optional C code while a pure-Perl fallback remains available. You must run it from a real console with a framebuffer-capable open source driver rather than inside X or with proprietary DRM drivers, and 24/32-bit modes are recommended for best performance and TrueType support. If you need compact, console-only graphics, fast blitting and image manipulation from Perl, Graphics::Framebuffer is a practical, well documented choice.

AsposeCellsCloud::Role is a small model class in the Aspose.Cells Cloud Perl SDK that represents a user or permission role used by the service. You use it to build, inspect, and pass role data such as id, name, and permissions when making API calls via the SDK’s ApiFactory and Configuration components. The module lets you work with role information as a native Perl object and handles the conversion to and from the JSON structures the REST API expects. It is helpful whenever you need to create, update, list, or delete roles or include role details in requests to the Aspose.Cells Cloud service.

XS::Parse::Sublike is a small XS helper library for people writing Perl keyword plugins that need to parse "sub"-style declarations. It provides a boot function to initialize hooks and a compact API to parse the usual pieces of a subroutine declaration such as an optional name, attributes, an optional signature and the code body, plus helpers to register custom sub-like keywords or prefixing keywords so your plugin can be invoked automatically. The module exposes hook points and a shared parse context so you can inspect or modify the parse at stages like attribute handling, signature start/finish and the creation of the CV or optree, and it offers experimental signature helpers to query or add parameters programmatically. This is an XS-level tool aimed at keyword/plugin authors and not intended for normal Perl code. The interface is still experimental and evolving so newer releases have added extended signature features including named and refalias parameters and additional signature inspection APIs, and ABI changes may require rebuilds of dependent modules.

Data::HashMap is a family of C-backed, type-specialized hash maps for Perl that trade Perl hash flexibility for much lower memory use and much higher speed. Each variant targets a specific key/value combination such as 16/32/64-bit integers, strings, or generic Perl SV* values and exposes both a keyword API that bypasses Perl method dispatch for maximum throughput and a convenient method API. Built-in features include configurable LRU eviction with an optional approximate mode for cheaper promotions, per-map and per-key TTL with lazy expiry, fast counter and atomic operations on integer variants, iteration and bulk snapshot helpers, and zero-copy read-only string access when you need the absolute fastest reads. The implementation is designed for real-world caches and hot workloads and shows large performance and memory advantages over Perl hashes. Keep in mind a few practical caveats documented by the author: TTL expiry is lazy, get_direct returns a read-only view that must not be held across map mutations, some integer variants require 64-bit Perl and reserve a couple of sentinel integers, and freeze output is native-endian only. If you want a compact, low-latency map or cache in Perl with LRU and TTL support this module is a strong fit.

PDL::Graphics::PLplot is the PDL bridge to the PLplot plotting library, offering a Perl object oriented API plus direct access to PLplot's lower level C routines so you can produce PNG, PostScript, X11 and other device outputs from PDL ndarrays. It makes common tasks simple with high level methods for XY plots, colored point plots, shaded contour and image plots, histograms, bar charts, strip plots, color keys and annotated text while exposing many options for colors, palettes, viewports, ticks and fonts. The module accepts PDL arrays directly and understands bad values so you can mask points or create gaps in lines, it can decorate in‑memory PDL images with the mem driver, and it supports advanced features like custom coordinate transforms, grid maps for irregular grids and stacked bars. Note that full compatibility requires PLplot 5.15.0 or newer and that a few low level calls have slightly different argument ordering because of the PDL wrapper, but overall this is a powerful, mature plotting backend for anyone using PDL who needs fine control or direct access to PLplot functionality.

DBIx::Spreadsheet makes an Excel or ODS workbook look like a database so you can run SQL queries against sheets using DBI. It treats each worksheet as a table and uses the first row as column names, filling empty headers with generated names and cleaning names for safe use. The module reads files through Spreadsheet::Read so it can handle CSV, XLS, XLSX and ODS when the matching parser modules are installed, and it exposes a DBI handle and helper methods to list available tables. Parsing and normalizing cell values is handled with pragmatic hacks, so results may vary between file formats, but for quick ad hoc querying and simple integrations this provides a convenient way to query spreadsheets with familiar SQL.

Quiq is a large, actively maintained Perl class library that bundles more than 260 small, reusable modules to speed up common development tasks. It provides utilities for filesystem and path handling, temporary files, logging and debugging, database access and result management, HTML and JavaScript generation, web clients and APIs, charting and plotting, image and media operations, XML and JSON handling, time and date utilities, plus domain helpers such as ZUGFeRD invoice XML generation and related validators. The collection is deliberately broad and pragmatic so you can pick stable building blocks instead of reinventing utility code for scripts, web tools, data pipelines, or quick prototypes. Installation is simple via cpanm Quiq and the project is under continuous development by Frank Seitz, with recent releases refining the database connection documentation and adding features and validators for electronic invoicing and a range of convenience methods across the library.

CPANSA::DB supplies the CPAN Security Advisory dataset as a ready-to-use Perl data structure, primarily to back CPAN::Audit but useful to any code that needs machine-readable vulnerability and advisory reports for CPAN modules. The distribution exposes a single subroutine, db, which returns a hashref of all reports so you can quickly integrate advisory data into audits, monitoring, or build tools. Releases include a JSON export and are signed with GPG and GitHub Attestations so you can verify the archive came from the official source, and GitHub releases include attestations and attestations instructions. The project is actively maintained with regular data updates; the recent 2026-04-19 update refreshed records and fixed a couple of improperly split affected_versions for Encode and IO::Socket. If you need an up-to-date, verifiable feed of CPAN vulnerability reports for security checks or automation, this module is likely relevant to you.

LaTeX::Replicase is a compact Perl template engine for programmatically filling real TeX/LaTeX files, letting you drive document content from Perl data structures rather than embedding logic in the template. You place simple tags into an existing .tex template to substitute scalars, arrays and hashes, to repeat table rows, and to add or suppress surrounding text based on whether values exist or are defined, and the module can write the filled file to disk or stream it to STDOUT. It includes options to treat templates as UTF‑8, to escape TeX metacharacters automatically, and to control handling of undefined names, debug output and silence, while protecting the original template from being overwritten. The interface is deliberately minimal so templates stay readable and all conditional logic stays in your Perl data, and common practical limits are documented such as avoiding spaces in file paths and preferring simple variable names. Recent updates added a tex_escape helper for safer TeX output and special magic values that let a value force early termination of the generated document by inserting \endinput or \end{document}, making it easier to control final output.

OpenAPI::Modern lets you validate HTTP requests and responses against OpenAPI v3.0, v3.1 and v3.2 documents so you can ensure clients and servers follow your API contract. It loads an OpenAPI document and uses a full JSON Schema evaluator to check paths, parameters, headers and bodies, converting many common request and response types into Mojolicious message objects and returning a structured JSON::Schema::Modern::Result that includes any deserialized data. The module helps find the matching path and operation in a spec, follows $ref chains, supports many query, cookie and path parameter styles, bundles up-to-date metaschemas, and can be cached for faster startup in preforked apps. A few areas are not yet implemented such as multipart and application/x-www-form-urlencoded media handling and it does not validate Authorization headers against security schemes. Recent releases improved parameter parsing, cookie and query decoding, added the with_defaults option to populate default values, and the latest 0.134 update adds a new JSON Schema format "media-range" and smarter media-type matching that takes parameters and structured suffixes into account. If you need runtime or test-time validation of messages against an OpenAPI spec and you work with Mojolicious or can convert your requests and responses to its message objects, this module is likely a good fit.

IPC::Manager::Client::SharedMem is a protocol plugin for IPC::Manager that stores client state, messages, and statistics in a SysV shared memory segment so multiple processes on the same host can exchange messages without a network. It serializes access with a SysV semaphore and keeps the whole dataset as JSON prefixed with a 4 byte network-order length, re-allocating a larger segment automatically if the data grows. The module is simple to use via ipcm_spawn and ipcm_connect and encodes the route as "shmid:semid". Because each mutation acquires the semaphore and reads and writes the entire segment, it is best suited to moderate-volume local IPC rather than extreme high-throughput workloads. Requires IPC::SysV 2.09 or later and was split out from IPC::Manager in its initial release.

DateTime::Format::Lite parses and formats datetimes using familiar strptime-style patterns and returns lightweight DateTime::Lite objects, making it a compact alternative to DateTime::Format::Strptime for projects that prefer fewer dependencies. You can set locale and time zone, supply a zone_map to disambiguate abbreviations, and the module resolves timezone abbreviations live against an included IANA tzdata SQLite database so lookups stay current. Common formatting and parsing paths are XS-accelerated when a C compiler is available at install time with a pure-Perl fallback otherwise. Errors are exposed via an error object or can be made fatal, one-shot convenience functions strptime and strftime are provided for quick use, and the formatter can be serialized for transport or storage.

Docopt is a Perl port of the Docopt command-line interface description language that turns a program's help or usage text into a working argument parser. You write a conventional help/usage block describing commands, options, positional arguments, optional groups, alternatives and repeating elements and docopt() extracts that specification and returns a HashRef of parsed options and arguments so your script can use them directly. The module reads the SYNOPSIS pod by default but you can supply your own doc text and control argv, automatic --help handling, --version, and parsing mode. It follows the familiar short/long option and default-value conventions, is based on the original Python implementation, and is aimed at developers who want a readable, spec-driven way to define and parse command-line interfaces. Note that the module is still under development and its API may change.

Math::MPC provides a Perl wrapper around the MPC C library so you can work with arbitrary‑precision complex numbers from Perl, control per‑component bit precision and rounding modes, and call the same high‑quality math routines MPC exposes, including basic arithmetic, powers and roots, exponentials and logarithms, trig and hyperbolic functions, comparisons, conversions and formatted I/O. The module overloads common operators so expressions like $a + $b, $a ** $b and sqrt($a) behave naturally and it interoperates with Math::MPFR and Math::GMP objects for mixed high‑precision workflows. Objects are normally blessed and automatically cleaned up when they go out of scope, with alternative “_nobless” initializers provided for manual memory control. You must have the GMP, MPFR and MPC C libraries installed (install GMP first, then MPFR, then MPC) and be aware of a few practical caveats noted by the author: overloaded operators use the current default rounding mode and string operands are parsed at the default precision, the sign of zero is not always handled by overloads, and passing the wrong argument types can cause a segfault. The recent 1.42 release tidied string representations of NaN/Inf and includes a workaround for a division bug in mpc‑1.4.0, making the module a solid choice if you need reliable, high‑precision complex arithmetic in Perl.

Term::Choose::Util is a small Perl toolkit for building terminal text-based selection dialogs that let users browse and pick directories, choose files, select one or many items from a list, compose numeric values, or edit simple settings via an interactive menu. It can be used as a functional interface or via an object, and exposes many customization options for prompts, colors, mouse support, layout and margins, hidden-file visibility, filtering, locale-aware decoding of filenames and current-selection labels, so you can adapt the look and behavior to your script. Options are passed as a hash reference and functions return the chosen value or update a supplied configuration hash when appropriate. The module targets Perl 5.10.1 and newer and expects standard IO encoding to be set correctly. Use it when you need quick, customizable terminal selection UIs in Perl programs.

Riemann::Client is a lightweight Perl client for sending events and running queries against a Riemann event and metric server. It builds events as Perl hashrefs and sends them over the network with simple options for host, port, and protocol, using TCP by default and offering UDP if you need it. You call send to deliver one or many events and query with a Riemann query string to retrieve matching states. TCP mode will try to reconnect on disconnect and will report communication errors, while UDP mode is constrained by Riemann's datagram size limit and will raise an exception for oversized messages. Use this module when you want to report service states, metrics, tags, timestamps and descriptions from Perl into a Riemann deployment.

DBIx::Class::InflateColumn::Serializer lets you transparently store Perl data structures in a single database column by automatically serializing on write and inflating back to native Perl structures on read for DBIx::Class result objects. You enable it by loading InflateColumn::Serializer and declaring a column with serializer_class set to JSON, YAML, or Storable so DBIx::Class handles conversion for you. The module includes safety checks that raise exceptions if the serialized payload won’t fit the column or if deserialization fails. It uses modern JSON backends such as JSON::MaybeXS where applicable. The most recent release updated the license and moved the repository to Codeberg without functional changes. This is handy when you need to persist nested or ad hoc data without adding tables, but you should avoid overusing it when that data would be better modeled in dedicated columns or related tables.

FCGI::Buffer is a lightweight helper for FastCGI scripts that verifies and speeds up the HTML your application emits by linting output, reducing and minifying content, compressing responses and taking advantage of client and server caches. You create one buffer per FCGI::Accept and configure options to enable HTML::Lint checking, gzip/Brotli/Zstd compression, automatic ETag and Last-Modified headers with 304 responses, and a server-side cache via CHI to avoid recomputing expensive pages; it can also write dynamic output to static files for direct serving. The module exposes simple init/set_options calls to tune behavior, generate cache keys and durations, and log activity, and it includes safeguards such as a NO_CACHE override for debugging. Known caveats noted by the author include HTML::Lint only supporting HTML4, possible JavaScript issues when using certain packing techniques, interactions with mod_deflate, and the need to capture Template output rather than print it directly. Recent releases added Zstd compression support and a handful of bug fixes and improved error messages.

Number::Base::SpreadsheetColumn is a tiny utility that converts Excel-style column labels like "A", "Z", and "AA" to zero-based numeric indexes and back, via two functions, from_scbase and to_scbase. It models spreadsheet columns as a base-26 system with a 1-based digit scheme so that from_scbase("A") yields 0 and to_scbase(0) yields "A". The module is ideal when you need to translate human-readable column names into programmatic indices or generate column headers while processing CSV files, spreadsheets, or any column-oriented data. It is focused, easy to use, and integrates into scripts without extra dependencies.

App::MARC::Leader is a small Perl base class for a command-line tool that reads MARC XML records and prints the record leader in a human readable form, showing values like record length, record status, type of record, bibliographic level, character coding scheme and the directory field lengths. It is intended for librarians, cataloging staff and developers who need a quick way to inspect MARC leader metadata or to embed/extend that functionality in scripts. The module exposes a simple new/run interface, supports localized and optional colorized output, and uses existing MARC and Unicode libraries under a BSD 2-Clause license.

Lingua::TermWeight is a compact Perl toolkit for computing term frequency (TF), inverse document frequency (IDF) and combined TF‑IDF weights so you can measure how important words are within one or many documents. It works with a pluggable word segmenter so you can use the simple SplitBySpace segmenter that ships with the module or provide a language‑specific tokenizer, and it can return raw or length‑normalized scores as hash or array references for easy consumption in search, text mining, feature extraction or keyword ranking workflows. The project is a modern, lightweight fork of Lingua::TFIDF that drops Japanese‑specific dependencies and moves to Object::Pad to keep the API familiar while making installation and maintenance simpler.

JSON::Schema::Modern is a Perl JSON Schema evaluator and validator that implements the full specification up through Draft 2020-12, letting you validate Perl data structures or JSON strings against reusable schema documents and receive a rich Result object describing errors, annotations and defaults. It supports older drafts as well, bundles the official metaschemas, and offers configurable behavior such as short-circuiting, format validation, stringy-numbers handling, content media-type and encoding support, custom format validators and vocabularies, callback hooks, and caching helpers for faster startup. You add schema documents to the evaluator and then call evaluate or evaluate_json_string to run validation, and you can extend or override format, encoding and media-type handling to suit your application. A few convenience features are not implemented yet, for example automatic loading of schema documents from disk or the network, and some format checks require optional CPAN modules. Also take care with untrusted schemas because embedded regular expressions and large-number operations can be expensive or unsafe.

Finance::Quote is a Perl library for retrieving stock, fund and bond quotes from a large collection of global data sources via a modular "quotelet" system, making it easy to ask for pricing, volume, dividend, NAV and other standard fields and to request results in a target currency using configurable currency-rate providers. You create a Finance::Quote object, load the modules you need or use the defaults, and call fetch to get results back as a two-dimensional hash keyed by symbol and label, with options to set timeouts, required labels, failover behavior and per-module API keys. The project includes many exchange-specific modules and separate CurrencyRates modules so you can plug in services that require API keys and control conversion fallbacks. Recent updates include fixes to parsing whitespace, an update to handle cookies required by Stooq and the addition of a TwelveData currency-rates backend. Note that the library does not let callers control the internal failover order and that the two-dimensional hash return style can be less convenient than nested references.

Config::Model is a mature Perl framework for describing, validating, migrating and interactively editing application configuration through a declarative model. You express your configuration schema as Perl data structures and the framework builds a validation engine, read/write backends and multiple user interfaces so you can inspect, edit and upgrade config safely from code or with the cme helper command. It supports common backends such as INI and Perl data files and can integrate Augeas for complex formats, and it can expose configuration as a virtual filesystem or drive GUI, curses or terminal UIs from the same model. The module is designed for maintainable, testable configuration tooling that separates model from processing logic, makes upgrades and audits easier and provides hooks for migration and automatic fixes. Recent releases include bug fixes around warped nodes and value handling and a change to use Filesys::Fuse3 for the Fuse UI.

Object::Iterate provides simple iterator-style control structures for objects that can yield a next element but cannot be turned into a list. It supplies iterate, igrep and imap which call an optional __init__, then loop while __more__ is true and fetch each element with __next__, setting $_ for the block just like foreach, and call an optional __final__ when done. Use it to apply foreach, grep or map semantics to streaming or virtual collections that would be impractical to materialize as an array. The expected method names can be changed via package variables ($Object::Iterate::Next, $More, $Init, $Final) but those names apply globally and AUTOLOADed methods cannot be detected, so you may need to localise the variables or provide real methods on your objects. The module is on GitHub and is released under the Artistic License 2.0.

Net::Async::WebSearch is an IO::Async-based search aggregator that fans a single query out to multiple pluggable web-search providers and merges their answers into a unified, deduplicated result set. It supports three modes: collect to wait for every provider and rank results with Reciprocal Rank Fusion, stream to emit unique results as each provider finishes, and race to return the first successful provider. You register provider instances (built-ins include DuckDuckGo, SearxNG, Serper, Brave, Google CSE, Yandex, Reddit and OAuth variants) and can stack multiple instances, tag them, and select or exclude them per call with simple selectors; per-provider option overrides and a shared Net::Async::HTTP client make configuration flexible. An optional fetch feature can GET top result pages and attach their bodies with configurable concurrency and timeouts, and every result is normalized with provenance and per-provider error reporting. The recent 0.002 release mainly tightens and clarifies the POD examples around provider instantiation and registration.

Mojo::DOM::Role::Style is a lightweight role that adds a convenient style() method to Mojo::DOM elements for reading and manipulating an element's inline CSS. Calling style with no arguments returns a Style::Value object that stringifies to the CSS text and can be used like a hash to read individual properties, while calling it with a single property name returns that property's value. You can replace the whole style by passing a raw CSS string or an even length list of property/value pairs, merge new properties by passing a hash reference, or remove the style attribute by passing undef. Setter calls return the element for method chaining which makes it handy in DOM transformations, scraping, or server side HTML generation. If you work with Mojo::DOM and need simple programmatic control over inline styles this role makes those operations concise and predictable.

SVGPDF is a Perl module that converts SVG images into PDF XObjects you can drop into PDF::API2 or PDF::Builder documents, producing one or more reusable graphics objects along with metadata about their viewBox and sizes. It accepts SVG from a filename, filehandle or string and understands a wide range of common SVG elements and style attributes so it works well for charts, MathJax output, QR codes, and other tool-generated SVGs. You can control page size, add a debug grid, combine multiple SVGs into a single object, and supply a font-handler callback to map SVG font-family/style requests to PDF fonts or rely on built-in corefont aliases, but note that corefonts only cover Latin-1 characters. The module documents coordinate and unit handling and returns an array of hashes describing each XObject for easy placement in a PDF page. Some SVG features are only partially implemented, such as percentage units, embedded SVG and preserveAspectRatio, and other features like gradients, transparency, clipping, masking and text-on-path are not supported. Recent updates improved color parsing and handling of global color styles for text and tspan elements and fixed platform-specific test issues, making color handling and text rendering more robust.

Net::Async::Gearman is a small Perl adaptor that integrates the Gearman protocol with the IO::Async event loop, providing an async-friendly wrapper around Protocol::Gearman. It is a low-level building block rather than a user-facing API, so you should normally use the higher-level Net::Async::Gearman::Client; the module mainly exposes an async connect method that takes the same arguments as IO::Async::Handle and defaults to Gearman’s usual port 4730.

Module::Extract::Use scans Perl source files without running them to identify modules that are explicitly loaded with use or require and to detect inheritance declared via parent or base. It offers simple calls to return either a plain list of namespaces or detailed records that include any requested version, the import list, whether the entry looks like a pragma, and a flag showing if the module came from parent/base rather than a direct use. Because it uses static analysis it will not find modules loaded dynamically at runtime, for example via eval or variable requires. The API is lightweight: instantiate, call get_modules or get_modules_with_details, and check error for parse problems. This makes it handy for audits, dependency discovery, and tooling that needs to know the explicit, statically declared dependencies of Perl code.