CPANscan

GD is the canonical Perl interface to the libgd graphics library that lets you create, modify and export bitmap images from Perl scripts without needing a full graphics application. It provides core classes like GD::Image for pixel-level drawing and copying, GD::Font for bitmap fonts, GD::Polygon for shape building and GD::Simple for a higher-level, easier API, and it can read and write a wide range of formats including PNG, JPEG, GIF and newer types such as WEBP, HEIF and AVIF when libgd supports them. You can draw primitives, text with TrueType support, filled shapes, brushes and styled lines, apply filters and interpolation, work with alpha transparency and tiled patterns, and build animated GIFs or do scaled and rotated copies for thumbnails or transformations. If you write server side image generators, charting scripts, simple image editors or automated thumbnailers in Perl, GD gives a compact, well tested toolset to do that. This is a mature module with ongoing fixes and format autodetection improvements, and the recent 2.86 release includes an important security patch addressing a command injection issue in a two-argument open call.

Novel::Robot is a small Perl toolkit for automating the collection, cleanup, and packaging of serialized web fiction; it gives you a Browser component to fetch chapters from web sites, a Parser to extract and sanitize chapter content, and a Packer to assemble those chapters into distributable files such as plain text or e-book packages. The suite is geared toward developers who need predictable, programmatic control to gather multi-chapter novels from the web and convert them into single readable outputs. If you want to automate scraping and conversion of online fiction rather than read it manually, this module set is directly relevant.

NetAddr::MAC is a small library for parsing, validating, formatting and manipulating hardware MAC addresses with both an object oriented API and a set of simple functional helpers. It understands EUI‑48 and EUI‑64 forms, accepts many common input styles, and can normalize addresses into Cisco, IEEE, Microsoft, PostgreSQL, Token Ring and other vendor formats or produce the IPv6 autoconfiguration suffix. You can query address properties such as unicast, multicast, broadcast, locally versus universally administered, VRRP and HSRP patterns, convert between EUI‑48 and EUI‑64, and generate random addresses from a given OUI or prefix. Error handling defaults to returning undef with an accessible error string but can be configured to croak instead. The module deliberately omits vendor OUI lookups so use Net::MAC::Vendor for that task. This is a practical utility for network scripts and tools that need reliable MAC address parsing and formatting.

IP::Country::DB_File is a lightweight Perl module that maps IPv4 and IPv6 addresses to country codes by looking them up in a local Berkeley DB file. You build the database first with the included builder or the build_ipcc.pl script which compiles regional internet registry statistics into the DB and now fetches those files via HTTPS. Lookups are fast and done in pure Perl so the runtime has minimal dependencies and Math::Int64 is only needed when building IPv6 databases. The module mirrors the familiar IP::Country API and provides methods like inet_atocc and inet6_atocc as well as packed-address variants. Results are typically ISO‑3166 two-letter codes with a few generic codes like EU or AP, private ranges return "**", and failures return undef. This is a good fit if you want an offline, dependency-light, reasonably accurate IP-to-country solution without relying on third-party services.

IPC::Shareable lets you tie Perl variables to System V shared memory so multiple processes can share the same scalar, array, hash or complex data structure with minimal fuss. By default it serializes data as JSON for cross-language interoperability and portability, with Storable as an option when you need Perl-specific features like blessed objects, and it will automatically use JSON::XS if available for much better speed. Nested references are stored in separate child segments so deeply nested structures work naturally, but that increases the number of OS shared-memory segments and semaphores used so you should be aware of system limits. The module exposes lock and unlock methods and optional enforcement and warning flags to protect against concurrent read and write races while still relying on advisory locking among cooperating processes. It also includes conveniences such as a singleton helper to prevent multiple script instances, tools to inspect segments and semaphores, and targeted cleanup and testing helpers to remove orphaned segments left by crashed runs. Note that locks are inherited across forked children and that automatic segment destruction runs only on clean exits so you may need signal handlers when using the destroy option. If you need to share configuration or runtime state between Perl programs or across languages, IPC::Shareable gives you a pragmatic, feature rich way to do it while surfacing useful diagnostics and cleanup controls.

List::Search is a compact Perl utility for very fast lookups in sorted arrays, using a binary search to return the index of the first element equal to or greater than a given key and -1 when there is no match. It provides string, numeric and custom-comparator entry points so you can search lists sorted with cmp, <=> or any user supplied comparison routine, and it also offers convenience functions that just test membership. The module is ideal when you keep data in sorted order and need either quick membership checks or the correct insertion point without scanning the whole list. Recent maintenance moved the source to Codeberg and fixed packaging and export issues while ensuring the contains helpers reliably return false on misses, so the module remains small, well tested and easy to drop into existing Perl scripts.

Sub::Protected provides Java/C++ style protected access control for Perl subs so you can mark helper methods as callable only from their defining package or from subclasses. You enable it by adding the :Protected attribute to a subroutine or by listing sub names in use Sub::Protected qw(...), and the module wraps those subs at CHECK time so out-of-scope calls croak with a clear error. It offers test-friendly bypasses via $Sub::Protected::BYPASS or the HARNESS_ACTIVE convention and has a simple runtime configuration hash for disabling the harness bypass. Note that enforcement is runtime only, a raw coderef captured before wrapping can bypass the check, applying method modifiers afterwards may wrap the wrapper, the attribute is installed in UNIVERSAL so it affects the global namespace, and the implementation uses unguarded package globals so concurrent use across threads is not recommended.

Log::Abstraction is a compact logging layer for Perl that gives you a single, familiar API with standard levels like trace, debug, info, notice, warn and error/fatal while letting you send messages to many different backends such as code references, arrays, files or file descriptors, syslog, or a built‑in sendmail helper for alert emails. You configure it via constructor arguments, a config file or environment variables and can customize output with a format string that expands tokens like timestamp, level, message and environment values. The object keeps a per‑instance history of emitted messages, supports cloning with overrides and method chaining, and falls back to initializing Log::Log4perl when no backend is supplied. Options let you escalate warn and error to Carp carp or croak behavior and the sendmail backend supports rate limiting so you do not flood recipients. The module is GPL2 licensed, provided as‑is without warranty, and is handy whenever you need a flexible, backend‑agnostic logging solution for Perl applications.

Strada is a Perl interface for loading and calling functions compiled into Strada shared libraries so you can call native Strada code from Perl with minimal friction. It provides both a low level handle-and-function API and a higher level Strada::Library object that loads a .so, lists and describes exported functions, reports the library version, and calls functions by name using either C-style or package::function syntax. Common Strada types map automatically to Perl scalars and references so ints, numbers, strings, arrays, hashes and undef convert back and forth, and variadic functions are supported by passing an array reference. Argument limits are removed when built with libffi otherwise calls are limited to four arguments. The module requires the Strada runtime headers and Perl development headers to build and is distributed under GPLv2.

Geo::Address::Formatter converts a structured postal address (a Perl hash of components) into a readable, correctly ordered multiline address for the appropriate country using community-maintained templates. You supply a configuration path to the OpenCage address-formatting templates and then call format_address with your components and options such as country override, language-aware abbreviations, a custom template, or an only_address mode to omit non-address POI text. The module also provides instance creation for reuse in long-running processes and a final_components method to inspect the cleaned and normalized components produced during formatting. It is designed to handle the quirks of 200+ countries and comes with extensive test coverage via the templates repository at GitHub. The most recent updates bump required versions of Text::Hogan, Clone, and YAML::LibYAML for compatibility and earlier releases added speed improvements and a reusable instance method.

Atomic::Pipe is a Perl utility that guarantees whole, non-mangled messages when multiple processes or threads write into the same POSIX pipe. It breaks each message into PIPE_BUF-sized atomic chunks with a small header so readers can reassemble complete messages even when writers interleave, and it provides simple methods like pair(), write_message(), and read_message() for common use. There is a mixed-data mode that lets you mix ordinary stdout/stderr text with inline atomic bursts so you can extract structured payloads from noisy output, but it relies on three control characters so printing arbitrary binary data that includes those codes can confuse the parser. The module can also transparently compress messages and bursts with Zstandard to reduce wire size and often speed up large-message workloads, and it supports custom dictionaries and options for blocking, nonblocking, buffering, and pipe buffer resizing. It only works on POSIX-compliant pipes and platforms, and Zstd support is optional via Compress::Zstd and requires both ends to agree on settings. If you need robust inter-process message boundaries across multiple writers or want to embed atomic payloads inside normal output streams, Atomic::Pipe is a convenient, battle-tested solution.

Text::Hogan is a Perl implementation of the Mustache templating engine that is a statement-for-statement port of Twitter's hogan.js. It lets you compile Mustache templates into pure Perl code so templates render very quickly while remaining fully compliant with the Mustache specification. You work with a Compiler to produce Template objects and then render those templates against your data, making this a good fit for Perl projects that need portable, fast, and hogan.js-compatible templating.

Tvh::Htsp::Client is a compact Perl library for talking to a Tvheadend server over its HTSP protocol, intended for scripts that need to query channels, control the server, or extract the electronic program guide. It provides a simple constructor and methods to send and receive HTSP messages and to call Tvheadend's JSON API through HTSP, plus helpers to look up channel names and IDs so you can easily build queries or map results back to channels. The module also includes a raw deserialization routine that can decode HTSP message blobs and can be used to unpack epgdb.v3 dumps, which makes it handy for exporting EPG data to JSON. Recent releases added a channel UUID/ID lookup and the htsmsg_deserialise method to simplify parsing stored or streamed HTSP data. If you need to integrate Tvheadend into Perl tools or automate EPG and channel access, this module provides a straightforward, ready-to-use client.

Catalyst::Plugin::Authorization::ACL adds simple, path-oriented ACL support to Catalyst applications by letting you attach allow and deny rules to private action paths. You can express rules as role lists (when used with Catalyst::Plugin::Authorization::Roles), predicate subs or methods, or constant true/false, and there is also a flexible rule API that can use exceptions to explicitly allow or deny. Rules are checked from the most specific path outward and short circuit when a rule explicitly permits or blocks access, otherwise access is allowed by default. Denials can be handled by providing a private access_denied action, by using the provided acl_access_denied and acl_access_allowed hooks, or by calling forcibly_allow_access from the handler to continue execution. If you need straightforward per-path access control integrated into Catalyst private namespaces this module is a light, well maintained option and recent releases added convenience helpers for role-any checks and routine maintenance fixes.

Dist::Zilla::Plugin::GenerateFile::FromShareDir is a Dist::Zilla plugin that creates files in your distribution or repository from Text::Template templates stored in another distribution's sharedir. You give it the source template name and a destination filename, choose whether the generated file goes into the build or directly into the repo, and any extra configuration keys are passed into the template alongside handy objects like $zilla and $plugin. It supports specifying the source encoding (defaults to UTF-8) and lets you control when repository writes happen with a phase option. This is handy when you want bundles or other reusable dists to provide ready-made templates for multiple projects; if your template lives only in the current dist you can instead use GatherDir::Template or GenerateFile. The most recent release made a documentation fix to the -dist option.

Database::Abstraction is a lightweight, read-only ORM-like layer for Perl that lets you access CSV, PSV, XML, SQLite and BerkeleyDB data without writing SQL by providing a single, consistent API for fetching rows, columns and counts. You typically subclass it per dataset and then call methods such as fetchrow_hashref, selectall_arrayref or use the AUTOLOAD feature to retrieve a column by name, and it includes configurable caching, flexible logging and a "slurp" mode that keeps small files in memory for speed. It is useful when you need to switch underlying storage formats without changing application logic or when you want simple, read-heavy data access with minimal code. A few legacy quirks remain to be aware of, notably the default CSV delimiter is '!' rather than ',' and the module uses an "entry" column name by default, and XML slurping can be fragile on some files, but recent maintenance continues to improve reliability. The latest release fixed path handling for safer file opens and addressed a DBD::File safety check by canonicalizing directory paths.

HTTP::Tiny is a small, dependency-light HTTP/1.1 client for Perl that makes simple web requests without the overhead of a full user-agent like LWP::UserAgent. It supplies convenient methods for GET/POST/PUT/HEAD/PATCH/DELETE requests, a post_form helper, mirror for saving responses to files, streaming data callbacks, proxy and cookie-jar support, connection keep-alive and timeouts, and basic HTTPS when IO::Socket::SSL and Net::SSLeay are available. The module focuses on correct transport behavior and safe defaults, including TLS certificate verification turned on by default and recent security hardening that strips caller-supplied Authorization, Cookie and Proxy-Authorization headers on cross-origin redirects and prevents automatic https-to-http downgrades unless explicitly allowed. HTTP::Tiny is ideal when you need a reliable, simple HTTP client for scripting and small programs but not a full-featured browser emulator, and callers are expected to provide properly escaped URLs and handle higher-level features themselves.

Dist::Zilla::PluginBundle::Author::DBOOK is a prepackaged set of Dist::Zilla plugins that encodes the build, test, and release workflow Dan Book uses for his CPAN distributions. It wires together metadata generation for GitHub, README and CONTRIBUTING file creation, prereqs discovery from cpanfile or prereqs.json/yml, contributor tracking, git checks, version bumping, tagging and pushing, and common test and manifest handling so you can build and release a module with consistent, repeatable behavior. The bundle also lets you choose the installer plugin, enable POD tests, control the GitHub username used in metadata, and run a dry run of release steps via FAKE_RELEASE. It assumes your repo carries the usual prereq and Changes files and can regenerate files into the repository so the project can be built or installed without Dist::Zilla. Recent updates moved the CONTRIBUTING.md template into the distribution sharedir and added an AI contributions policy to that template.

Wanted is an XS extension that generalises Perl's wantarray so a subroutine can detect exactly how its return value will be used and tailor that return accordingly. It provides a simple want(...) interface plus helpers like wantref/howmany/context and replacement return primitives rreturn and lnoreturn for proper behaviour in lvalue and assignment situations, and it understands VOID, SCALAR, LIST, BOOL, LVALUE/RVALUE, reference types and assignment contexts so you can return scalars, lists, references or perform assignment side effects based on the caller's expectations. Wanted is a maintained fork of the older Want module with fixes for crashes that could occur in threads, tie methods and mod_perl handlers, and it also works with threads by preserving context at thread creation. Be aware of two limits inherited from Perl internals: lvalue context cannot reliably be detected inside eval blocks in modern Perls and want('CODE') can be misleading in scalar context when prototypes are involved, so avoid relying on those cases or use the documented workarounds.

Mojolicious::Plugin::BarefootJS makes it easy to run the BarefootJS server runtime inside a Mojolicious app by registering a "bf" helper that lazily creates a per-request BarefootJS instance backed by BarefootJS::Backend::Mojo and lets you render compiled marked templates as native Mojolicious templates. Install it with $self->plugin('BarefootJS') and then call the bf helper from controllers or templates to produce server-rendered output with the BarefootJS tooling you already use. If you prefer not to run under Mojolicious or PSGI, the same runtime can be driven by BarefootJS::Backend::Xslate using Text::Xslate. The plugin is lightweight, integrates with Mojolicious hooks, and has seen active maintenance through 2026 with recent releases that delivered the initial feature set including the bf helper, the Mojo backend, and a DevReload helper.

BarefootJS::Backend::Xslate is a lightweight rendering backend that lets the BarefootJS runtime render Text::Xslate Kolon templates. It works with a plain Text::Xslate instance so it has no web-framework dependency and runs in PSGI/Plack apps or standalone scripts. Designed to be paired with the @barefootjs/xslate compile-time adapter, it expects templates that call the runtime as a "bf" object and builds Text::Xslate for HTML with automatic escaping while supporting raw markup via mark_raw. You can construct it with an existing Text::Xslate object or by giving template paths and options, and you can override the JSON encoder. The module exposes the small set of operations the runtime needs, including encode_json, mark_raw, materialize and render_named, making it a drop-in bridge between BarefootJS and Xslate templates.

Object::HashBase is a small helper for quickly creating hash-backed Perl classes with an automatic new constructor, simple getter and setter methods, and constants for each field so you can avoid string-typos when accessing the underlying hash. You declare attributes when you import the module and use short prefixes to control behavior such as read-only, write-only, deprecated setters, no-setter, constant-only, or forcing a non-XS implementation. Construction works with key/value pairs, a copied hashref, or an ordered arrayref, and you get an init hook plus optional pre/post init hooks for defaulting and setup; single inheritance is supported and constants are propagated to subclasses. Recent releases added Role::Tiny integration and convenient import prefixes for declaring parent classes and composing roles, making it easier to use HashBase in role-based designs. If Class::XSAccessor is installed HashBase will create faster XS accessors by default, but note that taking raw references to object slots can break when XS is used, and you can opt out per-attribute with the '~' prefix. This module is a good fit when you want lightweight, dependency-light objects and clear, conventional accessors without a heavy object system.

Game::TileMap lets you define and query rectangular two-dimensional tile maps from simple string or array input by pairing character markers with objects in a reusable legend. It builds an immutable grid of Tile objects and supports single- or multi-character tiles, custom classes of objects (for example terrain, walls, or spawn points), and special handling for walls and voids. The module uses a bottom-left origin at [0,0], accepts decimal coordinates for containment and accessibility checks, and provides methods to fetch a tile, list all tiles of a class or type, render the map to a string, and mark positions for debugging. It is best used for static level layouts and map definitions rather than tracking dynamic game state, and you should note that map markers cannot be whitespace and legend entries must be truthy.

WWW::Mechanize::Chrome lets you control a Chrome or Chromium browser from Perl using the Chrome DevTools Protocol so you can drive modern, JavaScript‑heavy websites just as a human would. It provides high‑level methods to navigate pages, run JavaScript in the page, query DOM nodes with CSS selectors or XPath, fill and submit forms, intercept and modify network requests, capture screenshots or PDFs, and manage tabs and cookies, while hiding the low‑level JSON/DevTools plumbing. You do need a Chrome/Chromium binary on the machine and there are a few browser quirks and unsupported legacy WWW::Mechanize functions, but the module excels for automated testing, scraping dynamic single‑page apps, and producing rendered output. Recent releases improved compatibility with modern Chrome versions by using a temporary data directory by default and restored screenshot support in content_as_png, making it more robust with Chrome 148+ and later.

DateTime::Format::Natural turns casual, 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" or ranges like "1 April 10 am to 1 May 8am". It can also pull parsable date/time fragments out of larger text with extract_datetime, handle durations with parse_datetime_duration, and offers options to set the reference "now", choose time zone handling, control numeric date formats, prefer or demand future dates, and tweak daytime boundaries. The parser provides success() and error() so you can detect failures, and trace() for debugging, but be aware parse methods always return a DateTime object even on failure so you should check success() before using results. Recent updates add a calendar conversion layer allowing non‑Gregorian calendars and introduce built‑in holiday formats like christmas and new year, along with improved ISO8601 handling and fractional seconds support.

App::Ack is a small internal helper module for the ack command line search tool that collects a set of utility routines ack uses at runtime. It supplies ack-flavored warning and error output, prints the built-in help pages and subpages for file types and colors, returns the program version string, detects whether input is coming from a pipe, computes the proper exit code based on how many matches were found, and can show filetype associations for a filename. This module is intended for use by the ack script itself rather than as a standalone library, so most users will interact with ack directly rather than calling these functions.

CPANSA::DB exposes the CPAN Security Advisory dataset as a ready-to-use Perl data structure, providing a single db() subroutine that returns a hashref of all advisory reports; it is the data backend used by CPAN::Audit but can be consumed by any code that needs CPAN vulnerability or advisory information. Each release is also distributed with a GPG signature and a GitHub attestation so you can verify the archive came from the official source, and the same dataset is available as JSON and on GitHub for easy access.

Time::Str is a Perl library that parses and formats date and time strings across a wide range of standard formats and real-world variants, letting you convert text timestamps to Unix epoch seconds or to parsed components and render epoch values back to RFC3339, RFC2822, HTTP, SQL, ASN.1, iCal and many other common formats. Its three main routines are str2time to produce a numeric timestamp with optional fractional seconds, str2date to return validated components (year, month, day, hour, minute, second, nanosecond and timezone fields) without requiring a timezone, and time2str to format epochs with configurable precision or exact nanosecond control. The parser accepts ISO 8601/RFC3339 and a permissive "DateTime" grammar, supports timezone offsets and DST-aware timezone objects, and can resolve ambiguous abbreviations when you supply a timezone_map, while precision rules ensure predictable truncation when parsing and rounding when formatting. Time::Str ships with an optional XS backend for speed and a Pure‑Perl fallback, interoperates cleanly with DateTime, Time::Moment and Time::HiRes, and reports errors by croak so calling code can trap parse and usage failures. Note the documented limitations: month and day names are English only, ISO week and ordinal dates are not supported, years are limited to 0001–9999, and timezone abbreviations are captured but not auto-resolved unless you provide mappings.

BarefootJS is a server-side runtime for templates compiled from JSX/TSX into a marked template plus client JavaScript. It is engine- and framework-agnostic and delegates tasks that depend on the rendering environment, such as JSON marshalling, raw-string marking, JSX children handling, and named-template rendering, to pluggable backends. Shipping backends include BarefootJS::Backend::Xslate for Text::Xslate and BarefootJS::Backend::Mojo for Mojolicious, and the core itself only uses Perl core modules so you only pull in a template engine or web framework when you install a backend. Use this module when you want a single Perl runtime to drive JSX/TSX-style templates across different web frameworks and template engines. The distribution is newly released with the initial engine-agnostic runtime and backend-driven design.

DBIx::Class::Schema::GraphQL automatically generates a ready-to-run GraphQL::Schema from an existing DBIx::Class schema so you can expose your database as GraphQL without hand-crafting types or resolvers. It maps table columns to standard GraphQL scalars, exposes relationships as fields, produces singular lookups and plural "allX" queries with filtering, ordering and both offset and cursor pagination, and creates create/update/delete mutations for each source while handling composite primary keys. The module returns a GraphQL::Schema you can pass to GraphQL::Execution and the original DBIC schema as context, making integration straightforward. Bear in mind a few deliberate limitations: related fields are unfiltered, mutations accept only scalar inputs and update is a full update, cursors work only with primary-key ordering, custom SQL types become plain strings and there are no subscriptions, and you should include a scalar field (for example total) alongside nodes in plural queries to avoid a resolver quirk. This is the initial v0.0.1 release aimed at quickly exposing DBIx::Class models over GraphQL for typical CRUD workloads.