CPANscan

Graphics::Framebuffer is a pure-Perl graphics library for drawing directly to a Linux console framebuffer, offering a simple, immediate API for pixels, lines, shapes, filled primitives, gradients, TrueType text, image loading, animated GIF playback, blitting and basic transforms. It is aimed at developers who want lightweight, console-only graphics without X or a full GUI stack and exposes dozens of easy methods that take hashref parameters for speed. The module can use Imager and optional Inline::C acceleration to speed costly operations, supports multiple draw modes like normal, XOR, mask and alpha, and includes an emulation mode so you can develop offscreen on systems without a framebuffer. Important caveats are that it only works on framebuffer-capable drivers in a real console session, proprietary GPU drivers that do not expose a framebuffer will not work, and 24/32 bit modes are strongly recommended over 16 bit for correctness and performance. The package is mature and actively maintained; the current 7.03 release mainly updates documentation and adds a small Easter egg while recent releases improved testing, vsync handling, and added features like a pseudo 3D "ball" primitive and better handling of VirtualBox quirks.

App::PDFLibrarian is a small command-line toolkit for organizing academic PDF papers with embedded BibTeX metadata, letting you import PDFs, edit or rebuild their BibTeX entries, export bibliographies or key lists, replace or remove PDFs, and repair links or convert journal names to ISO4 abbreviations. It integrates with typical Unix tools like poppler-utils and ghostscript and installs via cpanm, so it is a good fit for researchers, librarians, or power users who prefer a scriptable, file-based way to keep a BibTeX-aware library of papers rather than using a heavyweight GUI reference manager.

IO::Compress::Brotli is a Perl module that creates Brotli-compressed data from either a whole buffer or a streaming source, making it easy to compress payloads for storage or web delivery. It provides a simple one-shot function bro that takes a scalar and returns compressed bytes and an object-oriented streaming interface via IO::Compress::Brotli->create that lets you set quality, window and mode and feed data in blocks with compress, flush and finish methods. Note that finish must be called to flush termination data and that the module currently does not implement the IO::Compress::Base interface though that is planned for a future release. The distribution bundles the Brotli library and has seen regular updates for compatibility and build fixes; the most recent 0.021 release reverted a prior low-level change and fixed potential memory leaks in error paths.

Zuzu is a tiny Perl helper for running ZuzuScript code from Perl, offering two simple functions: zuzu_eval to parse and evaluate a ZuzuScript source string and zuzu_evalfile to load a UTF‑8 script file and evaluate it. Both functions accept runtime options so you can control things like allowed modules and library search paths, and they return the result of evaluation or the created runtime. Use this module when you need a quick, one-shot way to embed or execute ZuzuScript from a Perl program without dealing directly with the parser and runtime internals.

App::FilenameKeyValueUtils provides a small suite of command line tools for working with filenames that embed key=value style metadata, built on the Filename::KeyValue conventions. The bundled utilities let you parse filenames to extract keys and values, normalize different representations into a consistent format, modify existing key/value pairs, and add or remove metadata while renaming batches of files. This makes the distribution useful when you need to organize or transform large numbers of files whose names carry structured information, for example photo or dataset collections and automated pipelines, and the tools are designed to be scriptable and easy to integrate into workflows. The project is available on CPAN with source on GitHub and is distributed under the same license as Perl.

Map::Metro::Plugin::Map::Lyon provides a ready-to-use dataset of the Lyon metro for the Map::Metro toolkit so you can load the network, run route queries, or use it for visualization and testing without building the topology yourself. The module encodes the four metro lines A through D and their stations and integrates with Map::Metro via Map::Metro->new('Lyon')->parse or the map-metro.pl command line. The latest release reflects the real-world extension of Line B in 2023 by adding two new stations, so the map stays current for routing and analysis. This is a straightforward convenience plugin for developers who need a realistic public transit graph for Lyon.

Dist::Zilla::Plugin::GitHub::CreateRelease is a Dist::Zilla plugin that automates creating a GitHub Release for your CPAN distribution and uploads the distribution archive to that release, optionally adding a checksum and formatted release notes pulled from SignReleaseNotes, a changelog, or a file. You install it into your dist.ini and run it after your build and tagging steps; it infers the repo and remote but lets you override branch, remote name, title template, draft status, checksum algorithm, and which identity file to use for GitHub credentials. Authentication is handled via Config::Identity::GitHub so you provide a ~/.github-identity (or repo-specific identity) with a personal access token that has write access to repository contents and releases. The plugin is useful if you want a reproducible, configurable step that publishes your CPAN release into GitHub Releases with attached artifacts and readable notes. The recent 0.0009 update fixes repository name detection and a ChangeLog-warning issue and adds a few robustness improvements including Sigstore signing support and JSON compatibility fixes.

DateTime::Format::Natural is a Perl module that converts informal, human-friendly date and time phrases into DateTime objects so your code can understand inputs like "next tuesday at 2am", "tomorrow morning", "10 weeks ago", ranges such as "1 April 10 am to 1 May 8am", and even extracts such expressions from larger text. You create a parser with DateTime::Format::Natural->new and can tweak options like the reference "now" DateTime, numeric date format, time zone, calendar, and whether to prefer or demand future dates. Use parse_datetime to get a single DateTime, parse_datetime_duration (in list context) to get one or two DateTime objects for spans, and extract_datetime to pull parsable date substrings; methods provide success and error information and a trace facility for debugging. Note that parse_datetime always returns a DateTime object even on failure so you should check success, and durations should be handled with parse_datetime_duration rather than parse_datetime. Overall it is a practical, extensible way to accept natural-language date input in Perl programs.

Modern::Open is a small compatibility module that brings modern filehandle behavior to older Perl releases. It autovivifies filehandle variables and applies autodie-style failure handling to open, opendir, sysopen, pipe, and accept so that failed operations die with helpful diagnostics when used in void context, and it enables the safer three-argument form of open on Perl 5.00503 and later. socket() will autovivify the handle but does not autodie and returns the underlying CORE::socket result. The module also forbids bareword filehandles and emits clear error messages for wrong argument counts or unknown modes, making legacy scripts safer and easier to migrate to modern Perl conventions.

Net::STOMP::Client::Wrapper is a compact convenience layer that combines a STOMP client and the RabbitMQ management HTTP API into one easy-to-use interface for common produce, consume, and monitoring tasks. It provides sensible defaults for a single RabbitMQ broker such as host 127.0.0.1, STOMP port 61613, guest/guest credentials, a default vhost and queue destination, and exposes simple methods to connect and subscribe, send messages, and fetch queue stats via management_api_get_queue. The module is aimed at straightforward scripts and services that work with one queue and one server and removes boilerplate so you can quickly stomp_connect or stomp_connect_subscribe, send or wait for frames, and query consumer and message counts. Be aware that the connection methods are intended to be called only once per wrapper instance.

GDPR::IAB::TCFv2 is a focused Perl toolkit for decoding and validating IAB TCF v2.3 consent strings, offering a parser object with full accessors and JSON output, a declarative Validator for per-vendor purpose and legal-basis checks, a CMPValidator that verifies CMP ids against IAB snapshots, a tiny one-liner helper for quick scripts, and a subcommand CLI with JSON/text modes plus a prebuilt Docker image for pipelines. The distribution is considered feature-complete for TCF v2.3 and entered maintenance mode in May 2026 so the maintainer will keep fixing bugs and security issues while welcoming community patches. Common uses include extracting consent fields, automating vendor validity checks, validating CMP lifecycle state, and embedding consent checks into shell or CI workflows. Recent updates improved validator parity with a Go reference implementation, tightened policy-version and disclosed-vendors checks, and added structured failure reasons such as CMPDeleted and CMPUnknown, making the validation behavior more predictable across languages. If you need a reliable, well-tested Perl implementation and convenient CLI/Docker tooling for TCF v2.3 consent handling this module is a practical fit.

Module::Generic is a comprehensive base class for building Perl objects quickly and consistently, providing ready-made typed accessors and mutators (numbers, booleans, datetimes, UUIDs, IPs, files, URIs, nested object and array types), an AUTOLOAD that maps hash keys to methods, and a create_class facility to generate classes and methods on the fly so you can model complex data without writing boilerplate. It bundles helpful utilities for error and exception management (including a Null object to allow safe chaining on error), logging and debug output, ANSI colour parsing for terminal messages, flexible serialization/deserialization via CBOR/Sereal/JSON/Storable backends, and many small helpers such as date parsing, symbol manipulation and ASN.1-like type checks. Performance-sensitive helpers are implemented in XS when available but fall back to pure Perl transparently, and the module aims to be thread-aware for global error storage, however the docs warn that dynamic class creation and symbol-table injection are not safe to perform after threads are spawned so those operations should be done at startup. If you want a feature-rich, extensible foundation for application-level objects and prefer convention and helpers over hand-writing accessors and serialization code, Module::Generic is highly relevant.

SIRTX::Font is a Perl toolkit for reading, writing and editing SIRTX bitmap font files, aimed at developers and tool authors working with terminal or legacy bitmap fonts. It gives you an object interface to load fonts, inspect and manipulate codepoints and glyphs, import glyph images or whole directories, convert PSF and Roman .hex fonts, build alias maps, deduplicate and garbage-collect unused glyphs, and render text to images via Image::Magick. The module also understands named character lists and provides helpers to check or trim a font to common codepage subsets, to auto-generate simple glyphs, and to add or analyse rich metadata such as version, weight, slant, tags and display colour. Many features are marked experimental and most methods will die on error, so SIRTX::Font is best used in scripted workflows and font tooling rather than as an end-user library. The recent v0.07 release expanded metadata support, added import_attributes and import_hex, improved sf-to-html output, and fixed several import and aliasing issues.

DateTime::Lite is a lightweight, drop-in replacement for DateTime that gives you the same API while trimming dependencies and improving common performance hotspots. It provides full calendar and clock arithmetic, nanosecond resolution, ISO/CLDR/BCP47-aware formatting and locale support, and robust timezone handling by reading standard TZif binaries and evaluating POSIX footer rules for future dates. The core math and hot paths are implemented in XS for speed, there is a pure-Perl fallback for systems without a C compiler, and timezone data is stored compactly in an included SQLite database with an optional process-level memory cache to boost repeated zone construction in long-lived processes. DateTime::Lite favors safe error handling by returning errors instead of dying by default and accepts complex locale tags that can even carry a -u-tz- extension to infer the time zone. Be aware that using the bundled SQLite engine introduces some native memory overhead and that you may want to enable the TimeZone memory cache for the best per-call speed in servers. Recent updates improved documentation for extended timezone aliases, made the TimeZone module auto-select the fastest JSON backend with JSON::PP as a fallback on older Perls, and fixed a subtle object-check bug in string equality handling.

Filename::Timestamp is a small utility for detecting and parsing dates and times embedded in file names so you can automate organizing or renaming collections of photos, videos and archives. Its single exportable function extract_timestamp_from_filename scans a name for common camera patterns and ISO‑8601 style timestamps and returns false if none are found or a hash with epoch plus broken‑out fields such as year, month, day, hour, minute and second when a match is found. The module understands explicit timezone offsets and will return tz_offset and epoch, and when no timezone is present it marks the time as "floating" and provides epoch_local and epoch_utc computed via Time::Local, with a convenience ymd field added in the latest release. The function is not exported by default and an "all" option to find multiple timestamps is documented but not yet implemented.

IPC::Shareable lets you tie Perl variables to System V shared memory so multiple processes can access the same data directly instead of passing messages. You can tie scalars, arrays, hashes or objects and store arbitrarily complex structures, with nested references mapped into their own shared-memory segments so deep structures consume additional segments. Data is serialized into the segments using JSON by default or Storable for richer Perl-only types, and the module will fall back to Storable when needed; for best JSON performance install JSON::XS. The API feels like ordinary tied variables but also exposes flock-style lock and unlock methods, optional enforced read and write protections to reduce race conditions, and utilities to inspect, map, remove and clean up segments, tag segments for test suites, and implement single-instance scripts. Note that locks are advisory unless you use the enforcement options, locks are inherited across forked processes, segment cleanup on exit runs only for clean exits unless you handle signals, and segment sizes and counts are limited by your operating system.

CXC::Exporter::Util is a small helper library for Perl modules that export symbols. It is not an exporter itself but provides tag-centric utilities that centralize export definitions in %EXPORT_TAGS and automatically populate @EXPORT and @EXPORT_OK so you do not forget symbols or duplicate lists. It also makes it easy to define named groups of constants with install_CONSTANTS, generating the constant functions and companion enumerator functions that return either the constants values or their names, which is handy for iteration or building type enums. A companion install_EXPORTS call folds those enumerators into the export tags and finalizes the exports. Optional UI helpers let a program accept human friendly names for constants and coerce them back to values, and those helpers are available when Exporter::Tiny is present. The module is simple and pragmatic and helps keep export metadata in one place but it does not itself detect or warn about name clashes between enumerator functions and constant functions.

App::karr is the engine behind karr, a Git-native kanban tool that keeps your board state inside Git refs (refs/karr/*) rather than in repository files, so task cards live as Markdown payloads with optional YAML frontmatter and changes are serialized back into refs to avoid file-level merge conflicts. The installed karr CLI presents a transient, materialized board view for each command and implements common operations like create, list, move, archive, backup and restore, while lower-level modules such as App::karr::Git, App::karr::BoardStore and App::karr::Task let you script and automate board inspection or manipulation from Perl. The project ships Docker images for easy vendoring and runtime isolation and the recent 0.300 release bundles libgit2 into the runtime image and adds karr-foundation, a single-shot daemon for periodically running agent commands across multiple karr boards. If you want Git to remain the transport and source of truth for task state and prefer a CLI or programmable API that works directly with Git refs, App::karr is a lightweight, practical choice.

App::CriticDB is a utility and Perl module for scanning large codebases with Perl::Critic and keeping a persistent store of policy violations so you can update files incrementally and produce quick reports without re-running Perl::Critic across everything. It currently stores violations in a local file using Storable, records file mtimes to skip unchanged files, removes entries for deleted files, and provides a perlcritic-like reporting interface to STDOUT plus a command line tool perlcriticdb. The tool is aimed at speeding up policy counting and ongoing analysis of large repositories and the author plans additional features such as more storage backends, finer-grained change detection, richer reporting hooks, and improved command line filtering. If you need to aggregate, cache, and report Perl::Critic findings for many files, this module simplifies and accelerates that workflow.

Git::Native is a lightweight Perl interface for working with Git repositories directly via libgit2 without spawning the git command. It is a Moo-based wrapper around Git::Libgit2 that uses FFI::Platypus so you can open or init repositories, create blobs, build trees and create commits programmatically inside your process. It provides convenience methods like open, open_ext, init and reference_name_is_valid so common repository tasks are simple and fast. Use it when you need native, non-forking Git operations as an alternative to modules that shell out to git. The author positions it against Git::Wrapper and Git::Repository which run the git binary, Git::Raw which is XS and unmaintained, and Git::PurePerl which is read-only.

Cpanel::JSON::XS is a cPanel-maintained fork of JSON::XS that provides fast and correct JSON encoding and decoding for Perl, implemented in C for high performance. It focuses on proper Unicode handling and preserving round-trip integrity while being strict and secure by default, though it offers many configurable modes for ASCII, latin1, binary, relaxed parsing, big numbers, and object serialization via TO_JSON or a tagged FREEZE/THAW protocol. The module supports incremental streaming parsing, detects BOMs, is thread safe, and is the backend that JSON::MaybeXS will pick when available, so it is a good choice when you need a battle-tested, high-performance JSON tool for Perl. The project is publicly maintained on GitHub with a bug tracker and the author notes it will be replaced by a JSON::Safe module in the future to provide safer defaults.

SignalWire is the Perl port of the SignalWire AI Agents SDK that helps you build, deploy, and run AI agents as small web services that expose HTTP endpoints and connect to the SignalWire platform. It gives a structured prompt model for composing agent prompts, lets you define local tool handlers in Perl or declarative DataMap tools that call external APIs without webhooks, and includes a skills system, context management for multi-step flows, ready-made agent prefabs, a multi-agent HTTP server, a WebSocket Relay client for real-time call control, and a REST client for synchronous API access. You can add capabilities like datetime, math, or web search, host multiple agents in one process, and wire handlers to return structured function results that your agent uses when interacting with users. The module expects SignalWire credentials via environment variables and is available under the MIT License from the project repository at https://github.com/signalwire/signalwire-agents-perl; note the POD mentions a minor documentation encoding glitch.

RT-Extension-AI brings generative AI into Request Tracker to help summarize ticket conversations, assess sentiment, suggest or rewrite responses, autocomplete editor text, translate content, and even guide administrators through creating new queues. It installs as an RT6 plugin and connects to any REST-based AI provider such as OpenAI or Google Gemini with configurable prompts, models, and per-queue settings so you can tune behavior and limit features where needed. The extension provides scripted actions that update ticket custom fields, editor integrations via a CKEditor plugin that insert AI suggestions into replies, and optional context files of past tickets to improve suggestion quality. Setup follows the standard Perl module installation and includes sample configuration showing provider credentials, feature flags, and prompt templates. Be aware that some editor features may call the AI service frequently and that provider authentication or small provider-specific adjustments may be required.

Geo::Coder::OpenCage is a Perl client for the OpenCage Geocoding API that makes forward and reverse geocoding easy to use from Perl programs. You provide an API key and call geocode with a location string to obtain coordinates or reverse_geocode with latitude and longitude to obtain address details, and the module returns a parsed Perl hashref containing status and results. It supports common API options such as language, result limit and country hints, uses HTTP::Tiny by default but lets you supply a custom HTTP client, and it always sets a module-specific User-Agent header. Responses are parsed for you so JSONP is not used and you should check the response status to detect errors or rate limits. If you need programmatic access to OpenCage geocoding from Perl this module provides a straightforward, ready-to-use interface.

Catalyst::Plugin::OpenIDConnect is a Catalyst plugin that enables your application to act as an OpenID Connect provider (authorization server), not as a client. It supplies the standard OIDC endpoints (discovery, authorize, token, userinfo, jwks, logout), RS256 JWT signing and verification, state and one-time code storage, and hooks for your controllers so you can integrate your own login flow and routing by extending the plugin controller. Configuration is done in your Catalyst config with issuer keys and client entries, and the plugin supports pluggable stores including an in-memory backend and a Redis-backed store for multi-process deployments. Recent releases focus on production-grade security hardening, adding PKCE for public clients, refresh-token rotation with server-side JTIs, stricter JWT claim validation and constant-time secret checks, fixes for open-redirect issues, and automatic HTTP security headers on OIDC responses, making it a solid choice when you need a configurable, secure OIDC authorization server inside a Catalyst app.

Data::ReqRep::Shared is a Linux-only, 64-bit Perl module that provides a high-performance shared-memory request/response channel so multiple clients can send requests to multiple worker processes and receive replies without a broker or per-connection sockets. It offers two flavors: Str for variable-length byte payloads with a mutex-protected arena and configurable fixed-size response slots, and Int for lock-free int64 requests that boosts single-process throughput for simple numeric messages. The API supports synchronous and asynchronous calls, timeouts, cancellation, batching on the server, and optional eventfd integration for easy event-loop wiring. Built-in crash recovery reclaims stale mutexes and abandoned slots and generation counters prevent ABA problems. You tune capacity, slot count, and response size to trade memory for concurrency, making this a strong choice for high-throughput MPMC IPC scenarios where you want low latency and no broker process.

Data::Queue::Shared is a Linux-only Perl library that implements high-performance, bounded multi-producer multi-consumer queues in shared memory for fast cross-process IPC. It offers lock-free integer queues (Vyukov MPMC) for very high throughput and compact per-slot storage, plus a futex-protected string queue with a circular arena for variable-length messages and deque operations for requeueing or work stealing. Backings include file-backed mmap, anonymous MAP_ANONYMOUS for fork-inherited sharing, and memfd for passing a single fd between unrelated processes, and the API includes nonblocking and blocking push/pop with futex timeouts, batch operations, optional eventfd integration for event loops, stats, and PID-based stale-lock recovery. The module is useful when you need a fast shared queue for job IDs, counters, or messages and want better performance than kernel message queues or pure-Perl solutions. The latest release fixes a missed-wakeup race in wait operations, changes batch push/pop to wake all relevant waiters instead of one, caps pop_multi requests at the queue capacity to avoid over-allocation, and stops eventfd_set from closing caller-supplied file descriptors.

Data::PubSub::Shared is a Linux-only, 64-bit-Perl library that implements a very fast publish/subscribe channel using shared memory and a circular ring buffer so multiple processes can broadcast messages with minimal overhead. Publishers write into a file-backed, anonymous, or memfd-backed mmap and subscribers read independently with their own cursors so reads never remove data and slow readers simply reset to the oldest available slot while lost messages are counted. The module offers several variants: lock-free Int, Int32, and Int16 modes for compact, high-throughput numeric payloads and a Str mode for variable-length strings where publishers are serialized by a mutex but subscribers remain lock-free; Str messages are stored in a capped arena (default 256 bytes). It includes futex-based blocking polls with timeouts, eventfd integration for event loops, batch publish and drain operations, per-subscriber lag and overflow stats, memfd support for fd passing, and keyword helpers. Throughput numbers are in the millions of messages per second for integer modes and very high for batched operations, making this a good fit for low-latency IPC, telemetry, logging, and event distribution where overwriting old messages is acceptable.

Data::Heap::Shared provides a binary min-heap priority queue that lives in shared memory so multiple Linux processes can push and pop integer (priority, value) pairs concurrently. It offers a simple API including push, pop, peek and pop_wait (blocking with optional timeout), plus construction from a memfd or an existing file descriptor and eventfd-based notification for wait/notify use cases. Operations are mutex-protected with futex waiting and the module implements PID-based stale-mutex recovery, but if a process dies mid-operation the mutex can be recovered while the heap data may be left partially sifted so you should clear and rebuild after recoveries in critical applications. The module is Linux-only and requires 64-bit Perl, delivers solid single- and multi-process throughput, and exposes stats and maintenance methods, and you should avoid sharing the backing file with untrusted processes because the mmap region is writable by any opener. Recent fixes cap the heap capacity at UINT32_MAX to prevent silent truncation and close backing fds on allocation failure to eliminate a memfd leak.

App::Netdisco is an open source, web‑based network management tool that uses SNMP to collect device data into a PostgreSQL database and expose it via a built-in web server and backend daemon. It helps network teams find a machine by MAC or IP and trace the exact switch port, manage port state such as shutdown, VLAN or PoE, generate inventory reports by vendor and software, and produce visual topology maps. The project provides command line utilities, a plugin system for custom extensions, container images and a public demo, and is intended for self‑hosted deployments that meet the Perl and PostgreSQL requirements and perform an initial device discovery to seed the database.