CPANscan

Sys::OsRelease::Lite is a lightweight Perl helper that reads the standard /etc/os-release file and exposes the operating system and distribution metadata to your scripts in a simple, consistent way. It provides a singleton interface with ready-made accessors for common fields like id, id_like, version_id and pretty_name, plus generic methods to list, check and fetch any discovered attributes, and a platform helper that maps common ID_LIKE values to familiar platform names. The module keeps dependencies minimal so it is suitable for use in system scripts, installers and containers and it will fall back to Perl's native osname if no os-release file is found. Recent changes added a Sys::OsRelease::Lite packaging variant to maintain compatibility with older Perls before 5.22 and adjusted the Lite delivery for CPAN, making the same functionality available on legacy systems.

Sys::OsRelease is a lightweight Perl helper for reading the standard /etc/os-release file used by Linux and BSD to identify the operating system and distribution. It provides a singleton-based interface with convenient read-only accessors like id(), id_like(), name() and many more, plus generic methods such as get(), has_attr(), found_attrs() and platform() to return a normalized platform name. The module keeps minimal dependencies and supports both class-style and object-style usage so scripts can easily detect OS type for configuration, packaging or installation logic. It requires Perl 5.22 or newer and a repackaged Sys::OsRelease::Lite exists for older Perl versions.

Perl::Dist::APPerl delivers APPerl, a single-file portable Perl runtime that runs the same binary across multiple x86_64 operating systems and can carry Perl modules and scripts inside the executable as a ZIP filesystem. Using the apperlm command you can create and manage build configurations, build from an existing APPerl or compile Perl and the Cosmopolitan libc from scratch for static builds that support XS extensions, and include CPAN distributions by pointing apperlm at tarballs or folders. At runtime APPerl can dispatch embedded scripts by path, by an environment variable, or by argv[0] so you can ship standalone Perl applications, bundle a consistent interpreter for teams, or carry Perl on a USB drive without installing anything. It also supports debugging features like syscall tracing and function tracing and notes that building from source requires Linux. Recent releases added official builds for Perl 5.42 and 5.44 along with a variety of build and test fixes to improve compatibility.

Getopt::Class is a lightweight wrapper around Getopt::Long that lets you declare a dictionary of typed command‑line options and group them into named classes so you can collect, validate and access related sets of options for different features of your program. You define each option with type, aliases, defaults and validation rules and the module converts parsed values into convenient typed objects (scalars, booleans, arrays, files, URIs, datetimes, hashes) that you can access as hash keys or as methods. It supports mirrored enable/disable and with/without forms, required and regexp checks, action callbacks, and class-level helpers to extract only the values relevant to a given feature, and it reports structured errors instead of dying. If you build command line tools that expose multiple feature areas or need richer validation and objectified option values, Getopt::Class simplifies wiring Getopt::Long into that workflow. The module is mature and actively maintained with a recent v1.2.0 release and updated dependencies.

Pod::Man converts Perl's POD documentation into *roff using the man macros so you can produce standard Unix manual pages viewable with man or nroff. You can run it via the pod2man script or use it as a parser object to read POD from files, strings, or filehandles and write formatted output to a file, handle, or string. The module defaults to UTF-8 output and provides options to control headers, footers, section number, output encoding, quote characters, and optional "guesswork" rules that simplify common Perl documentation patterns. On modern systems that use groff or mandoc UTF-8 output renders correctly but very old troff/nroff implementations may not support Unicode and Pod::Man offers a legacy "roff" mode for backward compatibility at the cost of poor non‑ASCII rendering. Note that some *roff quirks remain, such as sentence spacing and the treatment of hyphens and quotes, which Pod::Man handles conservatively to preserve command names and copy/paste behavior. Pod::Man is included in Perl core and is actively maintained.

OpenAPI::Modern is a Perl library that validates HTTP requests and responses against an OpenAPI v3.0, v3.1 or v3.2 document and returns a detailed JSON::Schema::Modern::Result describing any errors and the deserialized request or response data. It loads your OpenAPI description, uses the JSON::Schema::Modern evaluator to resolve $ref and schema dialects, and provides convenient methods such as validate_request, validate_response, find_path_item and recursive_get so you can map an incoming Mojo, Plack, Catalyst or Dancer2 message to the right operation and check parameters, headers, cookies, querystrings and bodies against the spec. The module bundles up-to-date metaschemas and media-type decoders, supports type coercion and optional default-population of missing values, and can be cached or serialized for faster startup in preforked deployments. Note that some less common features are not yet implemented, multipart messages are unsupported and the module does not itself enforce Authorization schemes, so for best results parse network messages into Mojolicious objects before validating. The most recent release fixes path matching for URIs containing URL-escaped characters and improves restoration of cached documents and format handlers after deserializing an OpenAPI::Modern object.

mb.pm is a single-file Perl tool that makes it easy to write and run Perl scripts containing multibyte literal text in many legacy encodings as well as UTF-8 and WTF-8, by transpiling MBCS source into safe octet-oriented Perl or by providing a runtime mb:: API for selective codepoint-aware operations. It supports Big5, Big5-HKSCS, EUC-JP, EUC-TW, GB18030, GBK, Shift_JIS / CP932, UHC, Johab, HP-15 and others, automatically escapes problematic multibyte sequences that collide with ASCII metacharacters, and rewrites regular expressions and character classes so they behave sensibly for multibyte codepoints while leaving traditional byte-oriented builtins unchanged. You can use it as a source filter on modern Perls, as a modulino wrapper (perl mb.pm script.pl) for older Perls, or call mb:: routines at runtime to get codepoint semantics where needed, and it also includes helpers for Windows globbing and filename handling. The author notes some tradeoffs and limits, for example the modulino wrapper path writes a transpiled .oo file and there are intentional omissions such as full Unicode property support and non ASCII casing, plus a few platform-specific quirks, but for anyone maintaining or writing Perl that must work with MBCS source text or porting JPerl-era scripts this module is highly practical.

CBOR::Free is a fast XS-based Perl library for encoding and decoding CBOR data, aimed at making compact binary data interchange easy from Perl. It converts common Perl values to CBOR and back, supports tagged values, Types::Serialiser booleans, optional preservation of shared or circular references, and several string-encoding modes so you can choose how text and binary data are represented. Decoding yields UTF-8-decoded Perl strings for CBOR text and undecoded scalars for binary, and the module will warn or throw on invalid or extra input so you get predictable error handling. Be aware that floating point behavior depends on your Perl build and that integer handling follows CBOR and Perl limits, so very large integers or non-IEEE floating types may need special handling. The distribution is experimental and its interface may change, but it is lightweight, performs competitively with other CBOR and binary serializers, and is licensed under the same terms as Perl.

JQ::Lite is a pure-Perl implementation of a jq-like JSON query engine that lets you run familiar dot-notation filters and pipelines from Perl code or the bundled jq-lite command-line tool without installing external binaries or XS modules. It supports traversal, optional-safe key access, array flattening and indexing, boolean filtering, pipe-style chaining, mapping/reduction helpers, many jq-compatible built-in functions, and an interactive REPL, and it returns native Perl scalars, arrayrefs, and hashrefs for further processing. The module is especially useful in minimal, locked-down, containerized, or air-gapped environments where the jq binary cannot be installed but jq-style querying is needed, and it can use JSON::PP by default with optional faster decoders if available. In the current 2.48 release the author fixed comparison handling for values produced by piped filters and restored reliable access to object fields named "count", improving correctness for chained queries.

JSON::Schema::Modern is a full-featured Perl evaluator and validator for JSON Schema that implements the current draft2020-12 specification and earlier drafts, letting you validate Perl data structures or JSON strings against rich schema documents. It provides a configurable evaluator with options for short-circuiting, strict unknown-keyword checking, format validation, custom format and media-type handlers, content decoding, and an option to surface default values discovered during validation, and it can register schema documents or resolved resources for reuse and caching. The module returns detailed result objects rather than just a pass/fail flag and includes traversal and schema-validation helpers useful for tooling such as OpenAPI processing. It supports serialization for caching large evaluator objects and provides hooks for adding custom encodings, media types and vocabularies. Note that it does not automatically load schema files from disk or the network, formats are treated as annotations by default unless enabled, and you should use a trusted JSON decoder such as Cpanel::JSON::XS to ensure correct typing. Recent updates improved media handling for application/x-www-form-urlencoded payloads and made cached schema deserialization more robust. If you need a standards-compliant, extensible JSON Schema engine in Perl for validation or API tooling, this module is highly relevant.

CPANSA::DB is a data-only Perl module that packages the CPAN Security Advisory database as a ready-to-use Perl data structure. Calling its single db() subroutine returns a hash reference containing all advisory reports so tools like CPAN::Audit or your own scripts can programmatically check modules and versions for known security issues. The distribution also provides the same data in JSON and is published on GitHub with GPG signatures and GitHub Attestations so you can verify authenticity. The dataset is updated regularly and recent releases have focused on trimming the data into a more compact format and keeping the advisory records current.

Catalyst::Plugin::JSONRPC::Server is a small plugin that adds JSON-RPC 2.0 request handling to Catalyst apps by giving your context two helpers, jsonrpc_register and jsonrpc_dispatch, so you can register method handlers inside a request and have the plugin parse, route and respond to JSON-RPC calls over HTTP. It builds a fresh dispatcher per request so handlers and any closures do not leak between requests, and you can tune behavior with configuration like max_body_bytes (default 10 MiB) or supply your own dispatcher to change limits such as max_batch (default 1000). Handlers receive the JSON-RPC params and return results or throw a Catalyst::Plugin::JSONRPC::Server::Error to signal JSON-RPC errors while a plain die becomes a guarded internal error. Dispatch writes the appropriate HTTP response, returning the response payload or undef for notifications, and there is a jsonrpc_dispatch_with method if you need to reuse or preconfigure a dispatcher. The distribution includes a runnable example app and client so you can see echo and sum handlers in action.

Stats::LikeR brings a compact, R-like toolkit of data frame operations and statistical routines to Perl with an emphasis on speed and familiar idioms, offering frame-aware functions that work on array-of-arrays, array-of-hashes, hash-of-arrays, and hash-of-hashes and a large suite of stats tools such as lm, glm, aov, anova, t_test, wilcox_test, chisq_test, fisher_test, kruskal_test, and many correlation and descriptive routines, plus data wrangling helpers like agg, group_by, merge, concat/rbind, melt, pivot_table, assign, dropna, fillna, ffill/bfill, drop_duplicates, select/drop_cols, csort, and utilities like vals, colnames, rownames, qcut, quantile, rank, and uniq. The API is styled to feel like List::Util and R idioms so you can group, aggregate, reshape, and join tables with concise calls while benefiting from XS-accelerated numeric cores for heavy work. The module also includes robust I/O with read_table and write_table that handle CSV/TSV and XLSX, the latter much faster and leaner in recent releases, and it aims to be portable back to older Perl 5.10. In the recent 0.24 release the interpolate routines were moved into XS giving large speedups for linear, pchip and spline methods and now match pandas/scipy behavior to high precision, read_table gained much faster XLSX parsing and lower memory use, and several convenience frame operations such as bfill, ffill, melt, pivot_table and drop_duplicates were added, so if you need R-style data frame workflows or statistical tests inside Perl with production performance, Stats::LikeR is likely relevant.

Gherkin is the Perl implementation of the Gherkin language parser and compiler used by the Cucumber project. It reads feature files (including Markdown-formatted Gherkin), parses them into an AST and compiles executable scenarios known as pickles, and emits protobuf-based Cucumber::Messages wrapped as NDJSON envelopes so downstream tools can consume a standard message stream. The API is stream-oriented: call Gherkin->from_paths or from_source and supply a unique-ID generator coderef and a sink coderef to receive Envelope messages, and control whether the Source, GherkinDocument (AST) and/or Pickle messages are included via options. The module respects encoding headers in feature files and provides a to_json helper on envelopes for UTF-8 NDJSON output. Note that older releases used plain hashes but modern versions send Cucumber::Messages objects, and recent updates added Markdown Gherkin support and the ability for a step to carry both a DocString and a data table, keeping the parser aligned with the evolving Gherkin grammar. If you are building Cucumber tooling or any pipeline that needs a canonical Gherkin parser in Perl, this module is directly relevant.

Pod::Simpler::Aoh is a small Perl module that takes POD documentation and converts it into a simple, program-friendly array of hashes so you can inspect, search, and manipulate sections of documentation from code. You create a parser, feed it a file or a string, and it returns an arrayref or array of hashes where each entry represents a POD section with keys like identifier, title, and content. There is an option to split content into element-level hashes for finer-grained processing, and convenience methods let you retrieve a single section by index or search the parsed POD by a key and value. The module builds on Pod::Simple and aims to make POD easier to work with in scripts and tools that need structured access to documentation.

Net::BitTorrent is a full-featured, modern BitTorrent client library for Perl 5.40+ that lets you embed a complete torrent engine into your programs while remaining agnostic about how you do I/O. It supports BitTorrent v2 and hybrid v1/v2 swarms, DHT, uTP, protocol encryption, magnet links and .torrent files, per-torrent storage and piece verification, and a simple event/callback API so you can add torrents, drive the engine with a tick loop or integrate it into IO::Async or Mojo::IOLoop, and control download/upload limits or persistent session state. The module exposes high-level methods such as add, add_magnet, add_infohash, wait, tick, save_state, and DHT helpers so developers can quickly join or seed swarms and react to events without reimplementing protocol details. The recent 2.1.0 release focuses on comprehensive security and robustness hardening, fixing several CVE-class issues, replacing insecure RNG usage, adding SSRF and IP safety checks, capping message and queue sizes, and tightening protocol validation and resource limits to make the client safer for use in production. If you need a configurable, actively maintained BitTorrent engine in Perl that emphasizes v2 support and secure defaults, Net::BitTorrent is a strong choice.

SQL::Abstract::Plugin::TableAlias is a lightweight plugin for SQL::Abstract that automatically assigns and applies table aliases when generating SQL, so your SELECT, FROM, JOIN, WHERE and ORDER BY clauses are consistently qualified without hand‑crafted aliasing. You enable it by loading the plugin into SQL::Abstract and optionally provide a talias list to control alias names, and it will rewrite column and join references to use those aliases which helps avoid ambiguous column names in complex queries. It builds on the ExtraClauses plugin and is designed to be simple and unobtrusive to existing SQL::Abstract usage. Recent fixes include correct handling of aliased column expressions using {-as => ...} and a housekeeping release that removed PAX headers.

YAML::Ordered::Conditional is a Perl helper that lets you put simple templating and conditional logic into an ordered YAML document and then compile that template into YAML text, a YAML file, or a native Perl data structure. It provides familiar constructs such as for/each loops, if/elsif/else branches and placeholder substitution so you can generate lists and records from a parameters hash while keeping the original key order intact. The interface is minimal: instantiate with new and use compile to process a YAML template with your parameters, or use the encode/decode helpers to convert between YAML and Perl structures. The module reuses the Struct::Conditional markup style and is handy for Perl developers who need predictable, order-preserving YAML generation for configuration or data templating.

YAML::As::Parsed is a lightweight fork of YAML::Tiny that reads and writes YAML while preserving the order of mapping keys. It substitutes Perl's normal unordered hashes with ordered hashes so iterating or rewriting a document returns keys in the same sequence they appeared in the file, which is handy for human-readable configuration files or any situation that needs deterministic output. The module keeps the familiar YAML::Tiny interface so you can use the same simple read/write operations and data access patterns. Recent updates moved the implementation to Tie::OrderedHash for ordering and refreshed tests and minimum Perl requirements.

YAML::Conditional provides a simple templating layer inside YAML so you can embed conditional and looping constructs (for, each, if, elsif, else and key matching) directly in a YAML document and compile it against a parameters hash to produce concrete YAML or a Perl data structure. You write YAML that describes conditional logic and placeholders and then call compile with your input YAML and a params hashref to render a final YAML string, write to a file, or return a Perl struct, while encode and decode methods offer convenient YAML serialization and deserialization. This is useful for generating environment-specific configs, data fixtures, or any YAML-driven output that changes based on input data without writing a separate templating system. Recent releases fixed file handling in decode (v1.01) and removed PAX headers (v1.03).

JSON::Ordered::Conditional is a Perl module that turns JSON documents into simple, ordered templates with conditionals and loops so you can generate JSON or Perl data structures from a set of input parameters. You write familiar constructs like if, elsif, else and a given block for switch style logic, chain tests with and or or, use regex and equality or numeric comparisons, interpolate placeholders from a params hash, and loop over arrays or hash keys with a for block to build arrays or objects. The API is straightforward you create a JSON::Ordered::Conditional object and call compile to produce a JSON string, a file, or a Perl structure, and helper methods handle encode and decode. This is handy for producing dynamic, predictable JSON output such as API payloads or configuration files without hand coding procedural generation.

JSON::Conditional is a small templating tool that lets you embed conditional logic and simple loops inside a JSON structure and then "compile" that template into a concrete JSON document or Perl data structure based on a parameters hash. You write JSON that contains blocks like if/elsif/else, given, and/or, plus for-each and for-keys loops, and use expressions such as regex matches, equality or numeric comparisons to drive which parts of the template are emitted, while placeholders like "{key}" are filled from your params. The module provides a compile method to produce a JSON string, a Perl structure, or write to a file, plus handy encode/decode helpers and file variants. If you need rule-driven or param-driven generation of JSON from declarative templates this makes the job simple and readable. Recent fixes addressed file handling in the decode method so decoding from files works correctly.

Struct::Conditional embeds a small conditional language inside Perl hashes so you can declaratively transform input parameters into an output data structure. You write a template struct that uses familiar keywords such as if, elsif, else, given, and, or, for and each to express branching, pattern or equality checks, placeholders like {param}, and loops over arrays or hashes. The module provides a simple API with new, compile and itterate to evaluate that template against a params hash and produce a populated Perl structure. This makes it easy to map, filter and reshape incoming data or build rule-driven templates without imperative code, and it is useful when you want readable, data-driven generation of nested structures in Perl.

PerlIO::via::UnComment is a tiny PerlIO layer that automatically strips lines that start with '#' from a file or stream on input or output, letting you open files with :via(UnComment) or apply it to STDIN/STDOUT so only uncommented source flows through; it is intended mainly as a development tool for tasks like testing or producing comment-free output and can be stacked with other PerlIO filters such as PerlIO::via::UnPod. The module has no extra dependencies, is simple and stable, and was adopted by a new maintainer in 2019.

Module::ScanDeps::Static is a small, pragmatic tool for discovering direct Perl dependencies by statically scanning a script or module for common declarations like use, require, parent and base. It can read files or STDIN and produce text, JSON, raw, or RPM-style requirement output, with options to include or exclude core modules, append installed versions when none are specified, and set a minimum Perl version to be considered core. The module itself returns only direct dependencies, and the distribution supplies a find-requires helper for recursive directory scans and cpanfile-style outputs. The scanner relies on regular expressions so it handles many common coding patterns, including base/parent with qw or curly braces, and the recent 1.8.1 release added recognition for Moo and Role::Tiny::With's with syntax and fixed RPM output. It is very useful for quick dependency audits but may miss complex or multi-line constructs because it is a static parser rather than a runtime resolver.

PersonName::Format is a pure-Perl library that renders personal names using CLDR person-name patterns so names appear correctly across languages and writing systems. It inspects the name parts to detect script and likely subtags, chooses an effective formatting locale when scripts differ, and applies configurable options such as length, formality, display order, usage, and optional surname-all-caps. You can format individual name hashes or objects, compile a frozen formatter for repeated use, or get structured parts for custom rendering or markup. The module is useful for web and application interfaces that must present, address, or monogram names in a standards-driven, locale-aware way.

Mojolicious::Plugin::BarefootJS integrates the BarefootJS server-side JavaScript runtime into Mojolicious by registering a per-request "bf" helper that lazily creates a BarefootJS instance backed by BarefootJS::Backend::Mojo and lets you render compiled BarefootJS templates as ordinary Mojolicious templates. It is a straightforward way to add server-side rendering of BarefootJS components to a Mojolicious app and to access the runtime from controllers and templates. If you run outside Mojolicious or under PSGI look at BarefootJS::Backend::Xslate which drives the same runtime without a web framework. A recent improvement makes the plugin load the build manifest lazily and cache it by mtime and size so booting before the first build no longer breaks SSR defaults and manifest changes are picked up without restarting the server.