CPANscan

Command::Run is a lightweight Perl utility for running external commands or invoking Perl code references while capturing their input and output. It offers a fluent, chainable interface to set command, stdin and stdout/stderr handling and exposes captured output via a temporary file path like /dev/fd/N so you can hand results to other programs, and it uses only core modules. For Perl code references it can run them in-process (nofork) and optionally in a raw mode to avoid encoding overhead and gain large speedups for tight loops. Recent releases fixed a PerlIO layer leak that affected long-running nofork usage and made run() accept temporary parameters such as command and stderr so passing a scalar reference to run now correctly captures error output.

Amazon::Signature4::Lite is a compact, dependency-light Perl module that builds AWS Signature Version 4 authorization headers for S3 and other AWS services. You create a signer with your access key, secret key, region and optional session token, then call sign with the HTTP method, URL, any extra headers and the payload to get a hashref of ready-to-send headers such as Authorization, x-amz-date, x-amz-content-sha256, host and x-amz-security-token when applicable. The API is designed to work directly with HTTP::Tiny-style scalars and hashrefs rather than LWP or HTTP::Request objects which makes it a good fit for lightweight scripts or environments where you want minimal dependencies. It also offers a helper to extract service and region from common AWS endpoint hostnames but that parsing is tuned to S3/AWS patterns rather than being a general URL parser.

Module::CoreList is a lookup library and command line tool that tells you which modules and which versions shipped with each Perl release. It provides a simple API to answer questions like when a module first appeared in core, whether a particular module and version are bundled with a given Perl, which modules match a pattern across releases, and what changed between two Perl versions. The distribution also exposes ready-made data structures you can inspect from code, such as per-release module/version maps, release dates, deprecation and removal information, and upstream or bug tracker pointers. That makes it useful for CPAN authors, system packagers, and developers who need to know if they can rely on a module being available without installing extra dependencies. There is broad coverage of modern Perls with all stable releases since 5.6.0 and development releases since 5.9.0 included and partial coverage for very old releases. The module is maintained by the Perl 5 Porters and is installed with a command line helper named corelist for quick interactive queries.

CPAN::Perl::Releases is a tiny utility module that maps every Perl release uploaded to CPAN to the relative "authors/id/" path where its tarball lives, making it easy for scripts and tools to locate specific Perl tarballs for download or inspection. You call perl_tarballs with a Perl version and get back a hashref showing available archive formats such as tar.gz, tar.bz2 or tar.xz and their CPAN paths, and there are convenience functions to list all known perl_versions and to list perl_pumpkins, the PAUSE IDs of the authors. The data is static but maintained regularly as new Perl releases and release candidates appear, and the package is kept up to date with recent releases such as the latest 2026 updates for v5.40.5-RC1 and v5.42.3-RC1.

Mojolicious::Plugin::Fondation::Auth::Token provides simple personal access token support for Fondation-based Mojolicious applications by adding an opt-in route condition fondation.bearer that lets API routes accept Bearer tokens. Tokens are random strings whose SHA-256 hashes are stored in an api_tokens table and are meant to be created outside HTTP flows via CLI or fixtures. When a route uses fondation.bearer it will accept a valid Bearer token or a normal cookie session, return 403 for invalid tokens and 401 for unauthenticated requests, and routes that do not opt in will reject any Bearer header with 403. The plugin integrates with Fondation::Auth and the DBIx async model component and works alongside Fondation permission and group checks so you can stack authorization conditions as needed. This is the initial 0.01 release.

CPANSA::DB is a small Perl module that ships the CPAN Security Advisory dataset as a ready-to-use Perl data structure. It exposes a single db function that returns a hash reference of all advisory reports so scripts and tools can programmatically check known security advisories for CPAN distributions. The module is primarily used by CPAN::Audit but can be consumed by any code that needs the advisory data, and a JSON equivalent is also available. Releases are published on GitHub and include GPG signatures and GitHub attestations so you can verify the archive and trust the data before using it.

App::sdif is a small suite of terminal tools for making diffs easier to read and track. The sdif command prints diffs side-by-side with color, column and tab controls and works smoothly as a git pager so you can read git diff, log or show output in a friendly two-column layout. The cdif tool adds fine-grained visual effects that highlight changed words or characters and can use MeCab for better tokenization of Japanese text. The watchdiff utility repeatedly runs one or more commands and displays their output with visual emphasis on what changed so you can monitor live differences. The package is configurable via dotfiles, includes many options for color, visibility and truncation, and recent releases fixed a watchdiff regression so commands actually execute again and restored support for multiple --exec entries.

Mojolicious::Plugin::Fondation::Asset is a thin wrapper around Mojolicious::Plugin::AssetPack that gathers asset rules from all Fondation plugins, merges them into a single assets/assetpack.def file via the included "asset generate" command, and processes those bundles so they are available to your app. The generate command normalizes remote fetch directives so external URLs are treated correctly and caches downloaded files so they are not re-fetched at runtime. At startup the plugin only loads AssetPack if the merged assetpack.def exists, registers plugin public directories as stores, and calls process to expose assets to templates while emitting a warning and continuing if the def is missing. Use the "-y" option to overwrite without prompting. Recent releases require Fondation >= 0.05 to include the built-in share/assets/assetpack.def and add GitHub issue tracking in the module metadata.

Devel::LeakGuard::Object is a small utility for detecting Perl object memory leaks by counting blessed instances per class and reporting any imbalances that indicate leaked allocations. You can track a single object, wrap a block of code with leakguard to catch leaks within that scope, or enable global tracking so every bless is monitored and a summary can be shown at program exit. The leakguard call can warn, die or call a custom callback when leaks are found and offers filtering and tolerance options via only, exclude and expect so you can ignore or allow known, acceptable allocations. The module also exposes leakstate and track for programmatic inspection and a status summary facility. Be sure to load it early so it can intercept bless calls and note that overloading bless makes object creation somewhat slower, although the author reports the slowdown is small for typical programs.

Sys::Async::Virt is an asynchronous Perl client that implements the LibVirt remote protocol so you can control hypervisors remotely or locally using non blocking RPCs. It exposes an object oriented API that maps most libvirt protocol calls to methods which return Futures and can be awaited with Future::AsyncAwait, and it supports event subscriptions and callback objects for domains, networks, storage pools and node devices. The module translates C conventions into Perl friendly types by converting bitmap fields into arrays of booleans and representing typed parameters as descriptive hashes, and it ships with a large set of libvirt constants for flags and event ids. Generated against libvirt protocol v12.6.0, it works with newer servers while calls may fail on older servers that lack specific features, and the distribution is currently experimental with a few documented limitations and unimplemented entry points such as some file descriptor related calls. Choose this module when you need programmatic, asynchronous control of libvirt managed resources from Perl and can tolerate the noted gaps in protocol coverage.

Mojolicious::Sessions::Store provides server-side session storage for the Mojolicious web framework by replacing the default signed-cookie approach with a model where the browser only holds a signed cookie containing a session ID and all session data is kept in a backend of your choice. It is a drop-in change for application code because the existing session helper works the same, and it supports configurable options carried over from Mojolicious::Sessions such as cookie name, domain, path, expiration, secure and samesite. A simple file-based backend is included and custom backends can be written by implementing load, save and delete methods, so you can store sessions on disk, in Redis, in a database or elsewhere. The module is lightweight and focused on moving session data off the client; the most recent release replaced a dependency with Mojo::Util::random_bytes and updated its GitHub issue metadata.

Protocol::Sys::Virt implements the libvirt RPC protocol in Perl, providing the low-level mechanics needed to build libvirt-compatible clients and, in principle, servers. It follows libvirt's versioning so it stays aligned with libvirt API releases and is particularly useful if you need a nonblocking, asynchronous approach to talking to libvirt from Perl because the higher-level Sys::Virt interface is blocking by design and Perl threading is impractical for that use case. This module is aimed at developers who need direct protocol-level control or want to build an async libvirt client in Perl rather than those looking for a polished, high-level virtualization management library.

Web::Request is a lightweight request object for PSGI/Plack applications that converts the raw PSGI environment into a simple, consistent API for reading client IP and host, scheme, method, paths, headers, cookies, body and query parameters, uploads, URI and session data and for creating response objects. It is designed to be mostly read-only so you should not mutate returned objects, with the single supported exception of the encoding attribute which you can change to control how request body and parameters are decoded and how new responses are encoded. You can construct it from a PSGI env or an HTTP::Request and it defaults to Web::Response for responses and Web::Request::Upload for uploads with iso8859-1 as the default decoding. The API closely follows Plack::Request but is aimed at application authors who want a slightly higher-level, more user-friendly interface. The recent 0.12 release clarifies encoding behavior when creating responses and fixes decoding of undefined query parameters for compatibility with newer URI versions. If you build PSGI apps and want a convenient, well-maintained wrapper around the environment to simplify routing and parameter handling, Web::Request is likely a good fit.

Mojolicious::Plugin::Fondation::Model::DBIx::Async is a Fondation plugin that integrates DBIx::Class::Async with Mojolicious so your DBIC queries run in a background worker pool instead of blocking the event loop. It provides simple helpers like schema_class, schema and model so controllers can obtain native DBIx::Class::Async ResultSets and get Future-based results from operations such as search, create and find. You declare named backends and models in your app config, the plugin auto-discovers Result and ResultSet classes from Fondation plugins, and each backend gets its own lazy-forked worker pool that is cleanly shut down on process exit. This makes it easy to keep web requests responsive while running parallel database work, though you should remember to retain Future chains to avoid premature garbage collection. Recent updates improve many_to_many prefetch handling and upgrade integration with async many-to-many relationship support.

DBIx::Class::Relationship::ManyToMany::Async is a small helper for DBIx::Class that creates non‑blocking, Future‑returning many‑to‑many accessors so you can use pivot relationships with DBIx::Class::Async worker pools. Given an existing has_many pivot and belongs_to target relationship it generates a read accessor that returns a Future resolving to an arrayref of related rows and helper methods like add_to_x, remove_from_x and set_x that return Futures for linking and unlinking targets. It is designed for people who already use DBIx::Class::Async and need the same many_to_many conveniences without blocking, but it assumes the target table uses a primary key named id and can hit JOIN issues if your relationship name is an SQL reserved word unless you enable proper quoting. The module is experimental and the API may change, and the latest 0.02 release fixes a bug where prefetched rows could return null by using the belongs_to accessor, uses the cached ResultSet directly, and corrects an internal package variable initialization.

Module::Pluggable is a lightweight helper for Perl modules that adds simple plugin discovery and loading to your code. You add it to a package and it exports a method (by default named "plugins") that scans one or more namespaces or directories for plugin modules and returns their package names or instantiated objects. It supports flexible options for where to search, how to filter or sort results, whether to require or instantiate plugins, depth limits, and hooks for handling require or instantiate errors, so you can tailor discovery to your application. Discovery happens at call time which makes runtime extension easy but can be cached for performance if you do not need dynamic loading. The module plays nicely with tools that expose files via @INC hooks and can use Module::Runtime when available for safer require behavior. If you want an easy, configurable way to give your module a plugin architecture without pulling in a heavy framework, Module::Pluggable is a practical and well established choice.

Version::Semantic is a Perl class for representing immutable Semantic Versioning (SemVer 2.0.0) numbers as objects so you can parse, print, compare and increment real semver strings including optional "v" prefixes, pre-release tags and build metadata. You create objects with parse() or new(), inspect attributes like major, minor, patch, prefix, pre_release and build, stringify versions for output, and use the built-in comparison behavior to order versions according to SemVer precedence. It also exposes the regular expression used for parsing via semver_re() and provides an increment() method that supports major, minor, patch and an experimental "trial" strategy for TRIAL pre-releases. Note that as of v2.0.0 parse() now returns undef for unparsable strings by default and only throws an error if you request a fatal parse, so code that relied on earlier behavior should be updated. This module is a good fit when you need accurate, comparable SemVer objects in Perl scripts or release tooling.

Mojolicious::Plugin::OAuth2::Server is a plugin that makes it straightforward to add a full OAuth2 authorization server and resource-server checks to a Mojolicious app. It implements the standard RFC6749 flows you are most likely to need, including Authorization Code, Implicit, Client Credentials and Resource Owner Password Credentials, and it delegates the heavy lifting to Net::OAuth2::AuthorizationServer while exposing simple controller helpers such as $c->oauth to validate Bearer tokens and scopes and oauth2_auth_request to build authorization redirects. The plugin can optionally emit JWT tokens so you can run stateless, multi-process servers if you supply a jwt_secret, but that mode trades off automatic token revocation. Extension grants are not implemented. Recent maintenance releases have updated compatibility with newer Mojolicious and Perl versions and tightened tests to satisfy modern JWT libraries.

Scalar::ValueTags::LineageTracking lets you attach, propagate, and collect source metadata on Perl scalar values so you can build data lineage for pipelines and tools like OpenLineage. You instantiate a tracker with tag_type 'string' (the default) or 'ref', then add or set source tags when data enters your system and those tags are carried forward automatically whenever new values are derived; you can retrieve or clear tags when data leaves your system. String tags are de-duplicated by their serialized text so you should produce canonical strings, while ref tags are de-duplicated by reference identity and therefore require reusing the same Perl reference for identical tags. The module exposes add_data_sources, set_data_sources, get_data_sources and clear_data_sources (which returns prior tags for reporting). Recent changes simplified the API by pluralizing the add/set methods and making clear_data_sources return previous sources, replacing the old get_and_clear behavior.

Table::Readable provides a tiny, human-editable text format and a small Perl API for storing and manipulating simple tables of key/value rows in UTF-8. Files consist of blocks of "key: value" pairs separated by blank lines and are read into Perl as an array of hashrefs, with simple rules for keys (spaces become underscores) and multiline values delimited by lines beginning with "%%". The module can read and write these tables, append rows, sort files, and build an index hash by a chosen key while optionally returning the original order, and it preserves leading and trailing whitespace via backslash escapes. The format intentionally avoids nesting, extra syntax, or complex escaping so it stays easy to edit by hand, and recent changes (v0.06) added an append_table function and a noslash option to control backslash handling. If you need a lightweight, human-friendly way to keep machine-readable lists or translation text files, this module gives a stable minimal parser and writer with Emacs and Go support available in the project repository.

WebService::Mailgun is a lightweight Perl client for the Mailgun HTTP API that lets Perl applications send messages and manage basic Mailgun resources without dealing with raw HTTP calls. It supports sending plain and MIME messages including attachments, managing mailing lists and their members, querying events with polling and fetching stored messages, and basic template operations with partial template support. You can configure the API key, domain and region (US or EU), and choose whether API errors raise exceptions via RaiseError, while error and error_status helpers give easy access to failures. Several Mailgun endpoints are not yet implemented, for example domains, stats, tags, suppressions, routes, webhooks and full email validation, so this module is best when you need straightforward sending, list management and event access from Perl. Recent releases improved testing by reading credentials from environment variables and migrated continuous integration to GitHub Actions.

DB::x is a tiny debugging helper that lets you drop lightweight breakpoints into Perl code without changing the surrounding logic, either by inserting DB::x to unconditionally stop execution or by using DB::x 'label' so the pause only happens when $DB::x{'label'} is set true from your main script. This makes it easy to toggle breaks for code paths that run frequently because you avoid adding per-call checks, and it integrates with the debugger hooks so you can control labeled breakpoints at runtime. Recent releases added an explicit conditional-debugging form (DB::x 'Feature') and several debugger command improvements, and the module requires Perl 5.12.0 or later.

POE::Component::Server::JSONUnix is a lightweight, event-driven server that listens on a Unix domain socket and exchanges newline-delimited JSON request/response messages, making it a simple local RPC or control endpoint for daemons and command-line tools. Built on POE, it exposes a pluggable command dispatch table you can populate at startup, add to at runtime, or provide by subclassing, and handlers may reply synchronously or asynchronously using a context object that carries the request and reply methods. Messages are single-line JSON objects with an optional id for correlation and the server includes handy built-ins like ping and commands for discovery. Security is handled both by Unix socket permissions and by an optional ownership-based authentication handshake that verifies a client by the owner of a temporary file, and you can enable a per-command allow/deny policy based on users or groups. The recent 0.1.0 release adds the auth_start/auth_verify handshake, a POE-based client and a simple blocking client, and the flexible permissions layer, so if you need a compact, extensible way to expose local control APIs on Unix this module is a strong candidate.

Stats::LikeR brings a rich set of R-like data frame operations, statistical tests and modeling tools to Perl with many performance-critical routines implemented in XS so common tasks run quickly and with low memory overhead. It understands multiple table shapes (array-of-hashes, hash-of-arrays, array-of-arrays and hash-of-hashes) and supplies data I/O and wrangling helpers such as read_table, write_table, view, melt, pivot_table, assign, concat and merge alongside numerical and inferential routines including lm, glm, aov, coxph, t_test, wilcox_test, chi-squared, Fisher, ROC/AUC, ROC DeLong CIs, ANOVA/oneway tests, survival analysis and many effect-size and post-hoc utilities. The API is designed to feel familiar to users of R and pandas so you can group, aggregate, reshape, bin, interpolate or join tables and then run the usual statistical summaries and tests without leaving Perl. Recent work focused on ergonomics and speed: p_adjust now accepts whole data frames and returns corrected values in the same shape, merge was reworked for much lower memory use and faster joins, and new helpers h2aoh / aoh2h make it easy to fold and unfold plain hashes into two-column tables. Note that a small incompatible change was introduced upstream: the ad-hoc '?' / 'h' help argument that some Perl wrappers previously accepted was removed in favor of the dedicated h() printer and write_table now defaults to not emitting row names unless requested. If you write Perl and need fast, R-like data manipulation and statistical routines without switching languages, this module is likely highly relevant.

Hash::SharedMem provides a fast, file-backed key/value store that lets multiple processes on the same host share mutable data by memory-mapping files, so you get low-latency interprocess communication without blocking. Keys and values are limited to octet (Latin-1) strings, though you can store complex Perl structures if you serialize them first with something like Sereal. The API gives handle-based access with explicit read/write modes, atomic single-key operations (including get-and-set and compare-and-set), snapshot handles for consistent read-only views, and whole-hash helpers for listing keys, counting items, and estimating storage. It also offers maintenance calls to idle or tidy a handle and per-handle event counters useful for profiling. The module is designed for cases where the dataset fits in RAM or a memory-backed filesystem, so it is ideal for local caches, counters, or daemon-shared state, but performance will suffer if the data is mostly on disk. Creation is not atomic and file ownership and permissions can be awkward in multiuser scenarios, and the on-disk files are not guaranteed to survive an OS crash in a consistent state.

Backblaze::B2V4 is a straightforward Perl client for Backblaze B2 Cloud Storage that lets you create buckets, upload and download files, list and inspect files, and manage bucket and file versions using the B2 V4 API. You instantiate a client with your application key and key ID and then use simple methods to upload small files or large files, download by file name or GUID, create or delete buckets, retrieve upload URLs and tokens, and make custom API calls via a generic send_request method. The distribution also ships a b2_client command line tool for quick get and put operations and defaults to enabling Backblaze server side encryption for new buckets. If you already use S3 tools note that Backblaze offers an S3 compatible API but this module targets the native B2 API. Recent fixes corrected an upload result bug and updated the CLI to display the new file GUID, and the installer can optionally test your credentials by attempting a sample download when provided with environment variables for a test file.

Google::ISBNNumbers is a tiny Perl module that fetches basic book metadata from the Google Books API when you give it an ISBN. You create the object with your Google API key and call lookup_isbn with an ISBN to receive a hashref containing fields like title, author_name, description, publication_date and cover_link. It is designed for simple scripts and tools that need a quick, reliable ISBN-to-metadata lookup without scraping or heavy dependencies. You will need a Google API key from the Cloud Console and for tests you must set that key in the GOOGLE_API_KEY environment variable. Note that a recent change removed the included test API key, so you now supply your own key for testing.

CGI::ACL is a compact Perl module for deciding whether a web client may run a CGI script by checking the client IP address, CIDR ranges, country of origin and whether the request comes from a major cloud provider. You can build an allowlist of IPs or CIDR blocks and switch to default-deny for countries with deny_country('*') while using allow_country() to whitelist specific ISO country codes. It can call out to CGI::Lingua to resolve country codes and it can detect cloud hosts using reverse DNS with forward confirmation, with the cloud block taking precedence over explicit IP allows. The all_denied method performs the checks and returns 1 to deny or 0 to allow, and the API supports runtime configuration via Object::Configure and method chaining. IPv4 and IPv6 are supported and DNS lookups use a synchronous timeout on non-Windows systems. Note that invalid IP strings are stored verbatim and ignored at lookup time and that VPNs or proxies can defeat IP-based controls.

Data::Text is a small object-oriented Perl helper for building and manipulating text in a cleaner, chainable way than raw scalars. It wraps common string operations into methods you can chain, so you can create or clone text objects, set or append strings or arrays, trim whitespace, replace words, change case, compute length, join lists with natural conjunctions and compare or stringify objects with overloaded operators. It accepts plain strings, arrays or other Data::Text objects as input and is handy when you want clearer, composable text handling in scripts or modules. The author notes limited Unicode/UTF-8 support historically but recent releases improved UTF-8 behavior for length and case methods and the current 0.20 release modernizes the codebase and testing while refining configuration calls.

DesktopWorkspace is a small Perl specification for describing what windows, applications, files, directories, and browser tabs should be opened to set up a desktop workspace. It expresses a workspace as a simple hash with an array of items where each item is exactly one of a URL, file, directory, or a program by name or path, and it includes handy flags such as new_browser_window, new_file_manager_window and a KDE activity name so tools can open things in the right context. The spec also supports grouping related items into the same Firefox or Dolphin window via firefox_window_num and dolphin_window_num so presets can recreate multi-window layouts, and it is intended to be implemented by modules under the DesktopWorkspace:: namespace that define presets like Coding or Writing. Note that a single specification currently targets one KDE activity and that the 1.x series is marked unstable. In the recent 1.0.1 release the maintainer made a backward-incompatible rename from app_name/app_path to prog_name/prog_path and added the window grouping properties and the new_file_manager_window option to give finer control when restoring a workspace.