CPANscan

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.

SPVM is a statically typed language that looks and feels like Perl but is designed for higher performance and tighter C and C++ integration. It offers Perl-like core functions and modules, ahead of time and just-in-time compilation, native threads and lightweight goroutine-like coroutines, and tools to run scripts, build standalone executables and call SPVM code from Perl programs, so you can write high‑speed routines in a familiar syntax and bind them to existing C or C++ libraries. The project includes a builder toolchain, resource and packaging support, and a Perl exchange API so Perl and SPVM can interoperate, but it has not yet reached a 1.0 stable release and the author warns that backward compatibility is not guaranteed. Recent work in the 0.99 series focuses on the build system and configuration APIs, with a May 2026 update that fixes a LinkInfo configuration bug and reorganizes several SPVM::Builder::Config classes and methods to make native and executable builds more robust.

Alien::Libgit2 is an installer helper that makes the libgit2 C library available to other Perl modules by either locating a suitable system libgit2 (via pkg-config, requiring version 1.5 or newer) or building a bundled copy with CMake so no network access is needed at install time. It exposes the usual integration points for XS consumers with cflags and libs and for FFI users with dynamic_libs so modules like Git::Libgit2 can link to libgit2 reliably. The current release bundles libgit2 1.9.3, includes updated CI, and has been tested on Debian, Alpine, and macOS, making it a straightforward choice if you need a predictable libgit2 dependency for CPAN modules.

Term::ANSIEncode is a Perl module and companion command-line tool that converts a simple bracketed markup language into ANSI escape sequences so you can produce colored, positioned and styled terminal output from Perl programs or scripts. You write human-friendly tokens such as [% RED %], [% BOLD %], [% LOCATE 10,5 %], box and frame blocks, horizontal rules, wrapped or justified text and small macros inside strings and pass them to ansi_output to render on a UTF-8 capable terminal. The module auto-detects terminal color capability including 256-color and 24-bit truecolor and supports RGB color tokens, a large Unicode symbol table (with an option to abbreviate the table for faster startup), and many frame and formatting tokens to build simple terminal UIs or decorative output. An executable named ansiencode ships with examples and helpers for exploring tokens and colors, and ongoing development has focused on expanding token and color support, improving symbol handling and polishing output and documentation.

Log::Abstraction is a lightweight logging abstraction for Perl that lets you send log messages to a variety of backends without tying your code to a particular logger implementation. You configure it with constructor arguments, a config file, or environment variables on non‑Windows systems and then use familiar methods like debug, info, notice, trace, warn, error and fatal while controlling the minimum level and querying is_debug or messages. Backends can be code references, arrays, files or file descriptors, objects, syslog, or an email sender for high‑priority alerts; formatting tokens are available for level, timestamp, callstack, class, message and environment variables. It defaults to Log::Log4perl but only loads what is needed and supports cloning logger objects with their state. Recent work adds a sendmail throttle so at most one alert email is sent per configured interval and email headers are sanitized, making it useful for apps that need flexible routing of logs and occasional alerting without changing logging calls.

Data::Sync::Shared implements five cross-process synchronization primitives — semaphore, barrier, reader-writer lock, condition variable with a built-in mutex, and a one-time init gate — by storing control state in mmap'ed shared memory and using Linux futexes for efficient blocking. It offers file-backed, anonymous (fork-inherited), and memfd-backed modes, scope-based guard objects that auto-release locks, timeouts on blocking operations, optional eventfd hooks for integrating with event loops, and PID-based detection and recovery when a holder process dies. Note that it is Linux-only and requires 64‑bit Perl, and because the shared memory is writable by any opener you should not expose backing files to untrusted processes. The recent release improved RWLock dead-reader recovery and bumped the RWLock map version, so existing RWLock maps must be recreated after upgrading. Use this module when you need fast, low-level, cross-process synchronization for things like connection pools, worker coordination, or shared data structures.

Data::Pool::Shared implements a fixed-size object pool in shared memory for Linux running 64-bit Perl, letting multiple processes allocate and free numbered slots much like a small cross-process allocator. It provides a raw byte pool plus typed variants for int64, int32, double and fixed-length strings with atomic operations like CAS, exchange and atomic add, and supports blocking, non-blocking and timed allocation as well as batch alloc/free for better throughput. The module is lock-free at the bitmap level and uses futexes to block when the pool is full, offers zero-copy read access via SVs and raw memory pointers for FFI or OpenGL, and has helpers such as RAII-style guards, memfd or anonymous mappings, and a recover_stale routine that reclaims slots owned by dead processes. It is designed for high performance in concurrent and multi-process scenarios but note that the shared mmap is writable by any process that can open it so you should avoid sharing backing files with untrusted processes and prefer anonymous or memfd modes for stronger isolation.

Data::Stack::Shared provides a lock-free, shared-memory LIFO stack for Linux programs written in 64-bit Perl, letting multiple processes push and pop values safely via an atomic top index and per-slot publication state, with futex-backed blocking and optional timeouts. It comes in two variants for 64-bit integers and fixed-length strings and supports anonymous, memfd, or file-backed shared regions so you can attach multiple processes to the same stack. Common operations include non-blocking and blocking push/pop, peek, size/capacity queries, an eventfd-based notification API, and a concurrency-safe drain that can reclaim slots left in a writing state by crashed pushers. The design is MPMC-safe and aims for high throughput while keeping publication and consumption ordered; recovery of stalled publishers is bounded to about two seconds and may silently drop a value if a still-running publisher is falsely reclaimed. Note that the on-disk format moved to version 2 and old v1 files from earlier releases will not open, and the mmap is writable by any process that opens it so you should not share backing files with untrusted code. Recent updates improved drain reliability by adding bounded recovery for stuck write slots and making slot publication CAS-only to avoid clobbering during recovery.

Data::RingBuffer::Shared provides a simple, high-performance fixed-size circular buffer in shared memory so multiple Linux processes can exchange numeric data without blocking writers. It comes in typed variants for 64-bit integers and doubles and always accepts writes by overwriting the oldest entries when full, while readers can fetch the most recent items by relative position or by absolute sequence number and can wait for new data with an optional timeout. The module exposes simple status and lifecycle operations such as size, capacity, head, count, to_list, clear, sync and unlink, supports creation from a file path, memfd or file descriptor, and integrates with eventfd for efficient notification. It is designed for use cases like metrics rings, sensor streams, rolling windows and debug traces, is very fast in single-process benchmarks, and is Linux-only and 64-bit Perl only. Be aware that the shared mmap region is writable by any process that opens it so do not share backing files with untrusted parties.

Data::Log::Shared provides an append-only write-ahead log stored in shared memory for Linux systems running 64-bit Perl. It lets multiple processes append variable-length records concurrently while other processes replay or tail the log from any position, and it can be backed by a file or a memfd. The API is simple: append returns an offset, read_entry and each_entry let readers iterate with built-in handling for in-flight or abandoned writes, wait_for blocks until new entries arrive, and truncate, reset and sync control lifecycle. Truncation marks old entries as logically invalid in a concurrency-safe way but does not reclaim physical space, and reset reclaims space by zeroing the region so it must only be used when no other process is accessing the log. The mmap region is writable by any process that opens it so do not share the backing file with untrusted processes. Recent v2 changes add a per-slot reserve size so readers can skip slots left by crashed writers, introduce an optional abandon_wait_us to control how long readers wait before skipping uncommitted slots, and make reset zero the data region; note that v1 logs must be recreated after this change. This module is designed for high-throughput multi-process logging and is a good fit for audit trails, event sourcing and debug logging where persistent, replayable records are required.

Data::Deque::Shared provides a high-performance shared-memory double-ended queue for Linux, implemented as a ring buffer with atomic CAS push/pop on both ends and futex-based blocking when empty or full. It comes in Int and fixed-max-length Str variants, supports anonymous, file-backed and memfd-backed mappings, and is safe for multi-producer/multi-consumer workloads thanks to a per-slot control word that enforces publication ordering. The module exposes blocking and nonblocking push/pop operations, convenience methods to inspect size and stats, an MPMC-safe drain() that can recover slots whose pushers crashed or stalled, and eventfd-based notification hooks. Note the usual constraints: Linux-only, 64-bit Perl, capacity limited to <= 2^31, and mmap regions are writable by any opener so do not share files with untrusted processes. Recent changes add a bounded (~2s) recovery path for stuck pushers, make slot publish CAS-only to avoid clobbers, and introduce a recoveries counter and stricter header validation for the new file format v2.