CPANscan

App::prepare4release is a helper tool for Perl module authors that automates the common chores of getting a distribution ready for release, especially for CPAN or Git hosting. Run from your distribution root it reads a prepare4release.json config or infers package, version, and distribution name from your Makefile.PL and main .pm, updates Makefile.PL metadata and a postamble that regenerates README.md from POD, injects status and license badges, and can create GitHub Actions or GitLab CI workflow files if requested. It also creates basic author tests under xt/author, warns about legacy Test::More/Test::Most usage, and with the --cpan option will ensure a LICENSE file, produce a README stub when needed, create a sensible MANIFEST.SKIP, and run perl Makefile.PL and make manifest so your tarball matches the tree. The tool is configurable via prepare4release.json and respects PREPARE4RELEASE_PERL_MAX for CI Perl-version ceilings. A recent 0.01 update makes the README badge injector a standalone generated script that embeds frozen badge Markdown so make README.md works in a fresh clone without needing App::prepare4release at build time and improves CPAN packaging steps around LICENSE and manifest creation. If you want a repeatable, low-effort way to tidy metadata, badges, CI, and basic author tests before publishing a Perl distribution, this tool is likely relevant.

WebService::Fastly is a Perl client that exposes most of the Fastly REST API so you can manage CDN services and account tasks from Perl code. It lets you create and configure services, domains, backends, and rules, upload application code, and handle user administration and billing reports, making it useful for developers and operations teams who want to automate deployment and configuration workflows or integrate Fastly controls into existing Perl tooling. The module follows Fastly's API structure and targets the API spec version 1.0.0, is published by Fastly Inc., and is available under the MIT license. For the latest endpoint details consult Fastly's Developer Hub.

Context::Preserve is a small Perl helper that saves you from writing separate void, scalar, and list code paths by running a target subroutine in the same context the caller used and then letting you manipulate or replace its results before returning them. It exports a single helper, preserve_context, which takes a block that runs the original code and an after or replace coderef to run afterward; use "after" to edit the aliased @_ to change what gets returned or use "replace" to return a fresh value from the second coderef. The module preserves the behavior of wantarray inside both the original and after blocks so the original function sees the correct context, and it supports the commonly used block-followed-by-argument calling style thanks to its prototype. The release is stable and lightweight, with recent updates focused on packaging and metadata fixes rather than API changes.

App::CrockfordBase32Utils provides command line tools and exportable functions for working with Crockford's Base32, the human friendly base32 alphabet designed for compact, unambiguous identifiers. It offers encode and decode operations, conversion between Base32 strings and integer decimals, and a flexible random generator that can produce one or many Base32 values with controls for length, uniqueness, and whether leading zeros are allowed. All operations return a consistent enveloped result array with HTTP-like status codes and optional metadata, which makes the tools easy to call from scripts or other programs. Use this distribution when you need readable short IDs, compact numeric-to-text conversions, or reliable generation of Crockford Base32 values; source and docs are available on MetaCPAN and GitHub.

Test2::Harness, known as "yath", is a modern replacement for the classic prove/Test::Harness that runs your Perl test suite faster and more flexibly. It is a command line harness that recurses into test directories by default and automatically adds lib, blib/lib and blib/arch to @INC so you do not need to pass -I or -l flags. Yath runs tests concurrently out of the box and can also preload expensive modules so many tests start from a warmed state, which often produces dramatic speedups for large suites. You can control behavior with project and user .yath.rc configuration files, launch a web server to inspect results (optional database backends required), and use test-file directives to opt tests out of preloading, forking, timeouts, or to mark duration, category, conflicts, job slot needs, and retries. For advanced use you can define custom preload stages and let yath allocate multiple job slots to tests so internal test concurrency is coordinated with the harness. The project focuses on Unix-like platforms and currently does not support Windows. Source and contribution info live on the project GitHub and the module is maintained by Chad Granum.

App::makefilepl2cpanfile is a small utility for modernizing Perl distributions by converting a classic Makefile.PL into a cpanfile without executing the original file, so it safely extracts runtime requirements and separate build, test, and configure requirements and can also include author or developer tools in a develop block. It can merge with an existing cpanfile and lets you control which developer tools to include via a YAML config file in your home config directory. The module exposes a simple generate() function that returns the cpanfile as a string for writing to disk, and it defaults to including development tools unless you opt out. The author provides the code as-is without warranty and notes specific license terms for personal versus other uses, so check the licence if you plan commercial or multi-user deployment.

Developer::Dashboard is a local "developer home" that centralizes your bookmarks, notes, helper actions, health checks, and repeatable workflows behind a single browser UI, a prompt-status layer, and a CLI so you stop scattering scripts, tabs, and remembered file paths. It gives saved and transient dashboard pages, file-backed collectors that prepare cached state for fast prompt and web indicators, open-file helpers and path aliases, small data-query tools for JSON/YAML/TOML/properties, and a project-aware Docker Compose wrapper, all configurable per project and extensible with simple plugins. The tool is implemented in Perl but is language-agnostic in practice and is useful for mixed stacks that want one consistent local entrypoint for navigation, quick checks, and operational tasks. The recent 0.70 release fixes Template Toolkit rendering so page templates receive TITLE values correctly and preserves raw bookmark instruction text in transient play and view-source flows, improving editor fidelity and predictable rendering.

UTF8::R2 is a Perl utility that gives you explicit UTF‑8 codepoint handling without using Perl's UTF8 flag or changing the language's built‑in octet semantics. It supplies mb::* functions (length, substr, tr, index variants, etc.) and a tied %mb regex wrapper so you can opt into codepoint-aware operations and use several UTF‑8 variants including RFC3629, RFC2279, WTF‑8 and ja_JP‑optimized forms while leaving normal Perl functions working on raw octets. That makes it useful when you need to avoid mojibake, handle raw octet data like gaiji or filenames, or port JPerl or utf8-pragma scripts while keeping backwards compatibility with very old Perls (5.005_03 and later). Note that it supports only UTF‑8 style encodings and requires explicit mb:: or $mb{qr/...} syntax for codepoint semantics rather than changing global behavior. The recent 0.29 release improves test coverage and distribution quality, tightens warnings handling, and fixes several small compatibility issues.

PGPLOT::Device is a small utility that builds and manages PGPLOT device strings so your plotting code can cleanly handle both interactive windows and hardcopy output without littering the program with device-format checks. It makes it easy to auto-increment interactive window ids, interpolate variables (using ${name} with optional sprintf formats) into output filenames, automatically add appropriate file extensions, and track a usage counter (${devn}), and it exposes simple methods to get the next, current, or last device string and to test whether the device will change or is interactive or ephemeral. If you generate multiple plots or let users choose between onscreen and file output this module simplifies that logic, though you are usually better off using the PGPLOT::Device::PGWin helper for interactive use. Note that the module does not automatically know whether a particular hardcopy format supports multiple pages so formats such as PNG may produce numbered files. The current 0.12 release improved the PGWin helper by accepting lowercase hash keys in its constructor, adding a winopts accessor, and allowing a new set of window options to be passed to next so certain options like Justify and panel counts can be updated without reopening the device.

Graphics::Toolkit::Color is a high level Perl API for creating, converting and generating related colors as immutable objects, making it easy to build palettes, gradients and complementary sets for screen work. You can construct colors from names, hex codes, CSS strings, numeric arrays or hashes in many color spaces and then ask for values in different formats and ranges with controlled precision. The module offers operations like mixing, adding or setting channels, inverting, applying gamma, measuring perceptual distance, checking gamut validity and producing color sets such as gradients, complements and clusters. RGB is the internal working space but perceptual spaces like OKLAB or CIELUV are supported and recommended for smooth blends and human‑centric distance calculations. Names can be resolved against built‑in or external naming schemes so you can map colors to familiar labels when needed. Objects are read only so methods return new colors and errors come back as return values rather than exceptions. Overall it is a practical toolkit for programmers who need robust, flexible color creation and palette generation for web or graphics applications.

Travel::Routing::DE::DBRIS is a Perl interface for querying Deutsche Bahn's bahn.de itinerary service and returning rich itinerary objects you can iterate in code. You give it origin and destination Location objects from Travel::Status::DE::DBRIS and it fetches connections made up of Connection and Segment objects that expose departure and arrival times, transfer and walking legs, and other segment details. The constructor accepts options for stopovers, departure datetime, language, modes of transit, passenger details for pricing, HTTP caching and user agent configuration so you can tune queries for your use case. The module is actively developed and marked as work in progress but recent releases improve robustness by handling DST-related backend timestamp quirks, showing arrival dates for overnight trips, and making transit mode identifiers case-insensitive.

IPC::Manager is a Perl library that makes it easy for multiple programs running on the same machine to exchange structured messages without a central broker. It gives you a simple spawn/connect API so one process can create a data store and hand out a short connection string that any local process can use to send and receive messages, and it supports pluggable serializers and a choice of transport backends so you can pick file-based directories, atomic pipes, Unix sockets, or DB-backed stores like SQLite, MySQL, MariaDB, and PostgreSQL. Messages are delivered as IPC::Manager::Message objects and the system supports both temporary guarded stores that clean themselves up and persistent stores for long-lived services. If you need lightweight, decentralized IPC for local scripts, daemons, or small services this module provides a practical, cross-platform way to pass structured payloads between processes. Recent updates have improved UnixSocket reliability on BSD systems and added IO::Select support to better handle I/O capabilities.

Catalyst::Action::REST is a small Catalyst action class that makes it easy to build RESTful endpoints by automatically dispatching requests to method-specific handlers such as foo_GET or foo_PUT when you mark an action with :ActionClass('REST'). It handles method-negotiation for you, returning a 405 with a populated Allow header when a method is not implemented and providing a default OPTIONS response and a HEAD-to-GET fallback, while allowing you to override the default not-implemented behavior with a custom handler. It also adds the Catalyst::TraitFor::Request::REST role to your request class and is meant to be used with Catalyst::Controller::REST when you want automatic serialization and deserialization of request and response bodies. If you are building REST APIs with Catalyst this module is directly relevant and saves you from writing repetitive dispatch and method-negotiation code, and recent releases added an optional RFC 7231 compliance mode and a json_options_encode option for JSON output while the latest patch mainly fixes test output handling.

Getopt::Long::Bash is a small Bash library that brings the convenience of Perl's Getopt::Long to shell scripts so you can declare all your options in one associative array and get long and short flags, bundled short options, GNU-style flexible ordering, multi-value arrays and key/value maps, built-in type and regex validation, automatic help text, callbacks, passthru for wrapper scripts, and support for git-style subcommands. It targets Bash 4.2 or later, installs from CPAN or by downloading the single getoptlong.sh file, and is simple to drop into existing scripts to replace brittle getopts logic. The project is MIT licensed and recent releases added a negative-alias syntax using ~ for option negation plus several bug fixes and improved documentation.

Physics::Ellipsometry::VASE is a Perl helper for fitting custom optical models to variable angle spectroscopic ellipsometry data using PDL. It wraps PDL::Fit::LM to perform Levenberg-Marquardt optimization and hides the fiddly mapping between a simple user model interface and the lmfit calling convention, automatically computing numerical Jacobians by finite differences. You feed it a whitespace-delimited data file of wavelength, angle, Psi and Delta and provide a model subroutine that accepts a PDL piddle of parameters and a piddle of input points and returns a flattened piddle of predicted Psi and Delta values. The constructor accepts a layers option (default 1) and you call fit with initial parameter guesses given as a PDL piddle to obtain fitted parameter piddles. It is useful for researchers or engineers who work with ellipsometry and already use Perl and PDL, and it depends on PDL, PDL::Fit::LM and PDL::NiceSlice.

WWW::Shodan::API is a Perl wrapper for the Shodan REST API that makes it easy to query Shodan from scripts and applications. It exposes straightforward methods to search the Shodan index, fetch host and service banners, run on-demand scans, manage network alerts and notifiers, look up DNS and domain information, and retrieve account and API plan details, returning native Perl data structures ready for automation or analysis. You create a client with your Shodan API key and call methods like search, host_ip, scan, create_alert or resolve_dns, keeping in mind that some searches consume query credits and features depend on your API plan. A recent refactor improved the internal request handling to support GET, POST, PUT and DELETE with JSON and form payloads and added many endpoints and helpers for facets, scans, alerts, notifiers, directory queries and HTTP header inspection, making the module more feature complete and flexible for security monitoring and integration tasks.

Dist::Zilla::Plugin::PPPort is a small Dist::Zilla plugin that inserts a Devel::PPPort header into your distribution so XS code and other C-level extensions can compile against older Perl releases. It writes a ppport.h file by default but lets you choose a different filename and choose the packaging style used for the default name, and you can specify the minimum Devel::PPPort version or force replacing any existing file. If you build and release modules that include native code and need backward compatibility across Perl versions, this plugin automates bundling the portability shims your users will need.

Inline::Module helps Perl authors package C or C++ code with their CPAN distributions without having to learn XS by providing Makefile hooks and small generated "stub" modules that let you write Inline::C or Inline::CPP code directly inside your Perl modules. You enable it from Makefile.PL with a postamble that names the module and optional settings, and it can automatically generate and update stub modules for development, manage the temporary .inline build cache, and by default bundle the necessary Inline support modules under your distribution's inc/ so end users can build smoothly. The module is primarily useful if you want to ship a Perl extension that embeds C/C++ via Inline and prefer a simpler workflow than raw XS, and recent releases added an option to disable bundling of Inline dependencies and improved automatic stub generation and build layout.

Module::Manifest::Skip helps CPAN authors and packaging tools manage MANIFEST.SKIP files by creating and updating a sensible, shared baseline of file-patterns that should be excluded from distributions. It ships with a canonical skip list but preserves any custom header in your existing MANIFEST.SKIP and lets you add or remove patterns from Perl or the command line, so packaging frameworks like Module::Install can keep your skips up to date without copying the whole list. The module is maintained to work with modern packaging practices and recent updates refreshed metadata and test coverage for compatibility with current tooling.

Chandra::EPUB is a lightweight EPUB reader written in Perl on top of the Chandra toolkit that opens and displays EPUB files in a GUI window, lets you navigate chapters, and renders embedded CSS and images. You can create an instance with new or call the convenience open method, supply optional width, height and title to control the display, and call run to start the reader, and the module also exposes load_epub and extract_body for programmatic access to book contents and XHTML body fragments if you want to integrate or process content yourself. This is the initial 0.01 release, aimed at providing a simple, usable reader and a foundation for further development, and issues or feature requests can be reported via CPAN's RT; the module is distributed under the Artistic License 2.0.

Time::ParseDate is a mature Perl utility that turns a wide range of human and machine date/time strings into epoch seconds so you can work with them programmatically. It understands many absolute formats such as ISO, month names and numeric forms, a rich set of relative expressions like "next Tuesday", "2 months", or "+3 secs", and recognizes times, timezones and optional fractional seconds. Parsing behavior is configurable with options to prefer UK dates, require whole-string matches, allow fuzzy matches, choose past or future for ambiguous dates and more. On success it returns seconds since Jan 1, 1970 or undef on failure and in list context it also returns leftover text or an error message. The module is actively maintained and recently added support for trailing Z or z as UTC in ISO 8601 timestamps, making it more compatible with modern timestamp formats.

Eshu is a fast, XS-powered tool for normalizing leading indentation in C, Perl and XS source files by tracking nesting and rewriting only the whitespace at the start of each line while leaving the rest of the code untouched. It understands language-specific constructs that affect indentation including C strings, comments and preprocessor directives, Perl heredocs, regexes and pod sections, and XS dual-mode files with XSUB boundaries and labels. The module exposes simple entry points to fix C, Perl or XS text or to auto-dispatch by language, and it can detect language from a filename. You can choose tabs or spaces and set the indentation width, and there is an option to indent preprocessor directives when desired. Eshu is implemented in C for single-pass speed and ships with a command line utility for in-place fixing, diffs, CI checks or stdin/stdout processing, making it a practical choice for keeping mixed-language codebases consistently indented.

Email::Abuse::Investigator is a Perl module that turns a raw spam or phishing message into actionable intelligence by parsing headers and bodies to identify the likely originating IPv4 address, extract all HTTP/HTTPS links and contact domains, resolve hostnames to IPs, and query RDAP/WHOIS to find network owners and abuse contacts. It collates MX and NS data, parses DKIM and list-unsubscribe headers, flags recently registered or lookalike domains, and produces a weighted risk assessment plus both an analyst-friendly full report and a compact, send-ready abuse report with deduplicated recipient addresses. The analyser is configurable with timeouts and trusted-relay exclusions and caches results per parsed message to avoid repeated lookups. It is designed to help security teams and abuse desks quickly determine who to contact and what evidence to include when reporting malicious mail. Note that the module extracts only IPv4 addresses, is not thread-safe, and WHOIS timeouts may be unreliable on some platforms such as Windows.

Alien::libwebsockets makes the libwebsockets C library easy to use from Perl by either finding an existing system installation or downloading and building a configured copy for you. It integrates with Perl build tools such as ExtUtils::MakeMaker and exposes compiler flags and linker settings so your XS or XS-dependent distribution can link against libwebsockets without manual setup. When it builds from source it enables libev, SSL, zlib, and the permessage-deflate extension to provide a fully featured runtime. A helper method, has_extensions, checks whether permessage-deflate support is present by looking for the relevant symbols, but that check is only reliable for installs the module built itself and may report false for untracked system libraries.

Amazon::Credentials is a Perl helper that finds and returns AWS credentials by walking a configurable chain of sources such as environment variables, container credential endpoints, EC2 instance metadata (IMDSv2), OIDC web‑identity tokens, and local ~/.aws profile files. It lets you control the search order and timeouts, disable metadata lookups for local or CI use, and supports SSO and role-based flows, plus convenience methods to format, check expiration, and refresh temporary credentials. The module can cache credentials and will try to encrypt or obfuscate them using Crypt::CBC with optional custom passkey, cipher, or encrypt/decrypt hooks, and it offers burn‑after‑read behavior when caching is disabled to reduce exposure. Debugging and logging are configurable with safeguards to avoid printing secrets, and a small CLI is provided for quick use. Note that it will not automatically assume roles defined only in profile files and it has not been tested on Windows.

Multi::Dispatch adds two new keywords, multi and multimethod, so you can write multiply dispatched Perl subroutines and methods that pick the right implementation automatically from richly featured signatures. You declare multiple variants of the same sub or method and the dispatcher chooses the best match by arity, type or class tests, value or :where clauses, destructured array or hash patterns, aliased and code parameters, literal matches, permuted argument orders, and more, and you can also use :before variants and next::variant to redispatch or adapt arguments. Multimethods integrate with inheritance and Object::Pad and can be declared as per-class with :common, and the module provides lexical debugging and annotation flags plus mechanisms to import or export variant sets between packages. It requires Perl 5.22 or later and several CPAN modules and the author notes a few practical limits, for example some interaction quirks with Object::Pad roles and that its PPR-based parsing may conflict with other keyword-adding modules. If you want declarative, pattern-rich overloading of subroutine behavior based on argument shapes or types, this module brings it to Perl cleanly and efficiently.

TOON is a small, pure-Perl encoder and decoder that gives you a JSON-like interface for the Token-Oriented Object Notation format, making it easy to serialize and parse Perl scalars, arrays and hashes into a readable TOON text form and back. It implements a pragmatic subset of TOON with support for null, true, false, numbers, JSON-style quoted strings, arrays using [ ... ] and objects using { key: value }, including bareword keys matching common identifier rules. You can use it as an object via TOON->new to enable options like pretty printing, canonical (sorted-key) output and configurable indentation, or use the functional helpers encode_toon, decode_toon, to_toon and from_toon for convenience, and parsing errors raise TOON::Error exceptions. Because this is a starter implementation written entirely in Perl it is lightweight and easy to integrate for basic TOON needs without external dependencies and this release is the initial 0.0.1 publication.

Data::HashMap::Shared implements very fast, file-backed shared-memory hash maps for Linux running 64-bit Perl, letting multiple processes open the same mmap file and share data with minimal locking. It ships as a family of type-specialized variants (integer-to-integer, string-to-string, mixed types, etc.) so lookups, atomic increments and compare-and-swap operations are implemented with native, low-overhead storage for peak throughput. The module uses futex-based locks and a seqlock-style fast read path so reads are effectively lock-free when LRU and TTL are disabled, and it adds optional features like per-key TTLs, an LRU clock eviction policy that avoids write contention, an arena for string storage with small-string inline storage, sharded maps for parallel writes, cursor-safe iteration and a keyword API for the absolute fastest call path. It also includes crash-detection and recovery of stale writers via PID tracking though cross-container PID namespaces are not supported, and it exposes rich diagnostics and file management tools. The recent 0.02 release notably expands the API with atomic swap/CAS, queue-style pop/shift/drain, batch set/get, TTL/LRU controls and stats, introduces lock-free clock/second-chance LRU reads, inline small-string nodes, SSE2 probe acceleration, a faster monotonic clock for TTLs and C-level sharding for parallelism, making it a strong choice when you need extremely fast, concurrent, cross-process shared hash tables on Linux.

Net::WebSocket::EVx is a lightweight Perl wrapper around the Wslay WebSocket library that plugs into the EV event loop to provide nonblocking WebSocket client and server I/O. It expects you to perform the HTTP/WebSocket handshake yourself and then hands a nonblocking filehandle to the module, after which you get callback hooks for complete messages, frame starts, frame chunks, frame ends and connection close events, plus APIs to queue messages, send fragmented streams, control read/write activity and wait for send-queue drain. The module adds support for RSV bits used by extensions such as permessage-deflate so you can implement compressed transfers, and it offers buffering control to stream large binary payloads without holding them all in memory. It is a fork of the older Net::WebSocket::EV that uses Alien::Wslay under the hood, and recent work focused on that switch, adding RSV support, hardening the XS layer and expanding tests. If you need an event-driven, high-performance WebSocket layer in Perl and are comfortable handling the initial handshake and nonblocking sockets, this module is a good fit.