CPANscan

Kubernetes::REST::Deprecated is a CPAN distribution that preserves clear, actionable redirects for old Kubernetes::REST v0 module names that were removed from the main distribution. Instead of allowing tools like cpanm to repeatedly reinstall obsolete stubs, this package supplies tiny "tombstone" modules that immediately fail at load time and tell the user which modern Kubernetes::REST API to use. It covers the large bulk of the old per-endpoint v0 API, providing 1012 redirect stubs plus ten helper-module tombstones, while deliberately not tombstoning the still-working V0Group compatibility shims. The distribution exists purely to register those replacement stubs on PAUSE and to ensure anyone attempting to install an old class sees a clear migration path rather than silently getting dead code.

Kubernetes::REST is a Perl client that exposes a simple, high level REST interface to the Kubernetes API and returns typed IO::K8s resource objects instead of raw hashes. It implements standard CRUD operations like list, get, create, update, patch and delete plus convenient helpers such as ensure, ensure_all and ensure_only for idempotent apply and pruning, and it supports streaming operations like watch and log. The client automatically builds API paths from resource metadata, can fetch the cluster resource map from the OpenAPI spec by default, and provides utilities for schema comparison and for async wrappers such as prepare_request, build_path, process_watch_chunk and process_log_chunk. Authentication is token based and the HTTP transport is pluggable so you can use the default LWP backend, HTTP::Tiny or supply an async backend that consumes the Role::IO interface. Note that duplex operations like exec, attach and port_forward require an IO backend with call_duplex and are not supported by the default sync backends. The module also supports multiple patch strategies, handles common race conditions during ensure, and is well suited for scripts, CLIs or integrating Kubernetes access into Perl services.

Math::Prime::Util is a comprehensive, high-performance Perl toolkit for working with prime numbers and related number theory tasks, offering fast sieves, primality tests (including BPSW and provable proofs), integer factoring, prime counting and nth-prime routines, random and provable prime generation, modular arithmetic, combinatorics and many utility functions for integers and sequences. It is implemented in XS for native-speed operations and can use a GMP-backed backend for much faster big integer work, though pure-Perl fallbacks exist; if you plan to work with large integers or cryptographic primes, installing the GMP backend is strongly recommended. The API covers both convenience iterators (forprimes, prime_iterator) and low-level routines (mulmod, powmod, invmod, sqrtmod), handles bigints transparently, is thread-safe, and ships small command-line tools for quick prime and factor tasks. If you want to generate, test, count, or manipulate primes or do heavy integer arithmetic inside Perl, this module is likely relevant and performant for your needs. In the recent 0.75 release the module now requires Perl 5.8.1 or later, the XS selection must be done before loading (prime_set_config can no longer toggle the XS option), and integer results that exceed native size are returned using the user-configured bigint class by default, so take care when upgrading code that depends on previous bigint behaviors.

Math::Prime::Util::GMP is a high-performance Perl extension that brings GMP-backed big-integer math and a comprehensive suite of number‑theory tools to Perl programs, making it ideal for prime testing, factorization, cryptographic key generation, and numeric experiments. It provides fast probabilistic and deterministic primality tests (including BPSW, Miller‑Rabin, Lucas variants, Proth, LLR and ECPP proofs), a range of factoring algorithms (trial division, Pollard Rho/Brent, p-1/p+1, ECM, SQUFOF and a quadratic sieve), sieving and prime‑generation utilities, modular arithmetic and root routines, combinatorial and special functions such as factorials, Bernoulli numbers, zeta and Pi, and a CSPRNG with random prime and proven‑prime generators. Inputs and outputs for large values use strings so you can work with big integers without changing your bigint setup, and the module is the fast GMP backend for Math::Prime::Util. The recent 0.54 release adds several usability and API improvements such as accepting negative inputs to factor, allowing lucas_sequence to take arbitrary integer P and Q, expanded multifactorial support, new small-integer helper functions, and various correctness and performance fixes including a faster BPSW path, so it is a solid choice if you need reliable, production‑grade big‑number arithmetic and prime/factoring capabilities in Perl.

PAGI::FastAPI is an asynchronous micro-framework for Perl 5.36+ that brings a FastAPI-like developer experience to Perl by combining non-blocking request handling via the PAGI spec and Future::AsyncAwait with Type::Tiny-based validation for query parameters and JSON bodies. It offers an async middleware pipeline, a simple dependency injection helper, a built-in CORS helper, and automatic OpenAPI 3.1 generation plus an interactive Swagger UI at /docs so your API is documented and discoverable out of the box. Routes are declared with async handlers and optional type constraints or dependency specs, validation errors are returned as HTTP 422 responses, and the app produces a PAGI-compatible code reference you can run with a PAGI server. The initial CPAN release implements the async routing engine, type-safe parameter and body validation, middleware and CORS support, dependency injection, and integrated OpenAPI/Swagger endpoints, making it a good fit if you want to build scalable, type-checked REST services in modern Perl.

Data::URIID is a utility for extracting identifiers and human-friendly metadata from URLs, QR codes and related objects so applications can display, link or otherwise act on internet resources. You create an extractor, call lookup on a URI or QR/code text, and receive a Result object that exposes IDs (by type) and attributes such as display names, icons or thumbnails, with support for both offline and optional online lookups and configurable user agent and language preferences. The module integrates with Data::Identifier and understands many common identifier schemes, barcodes and special URI forms (geo, ni, tag:, acct: and more), offers selective control over which services are allowed to go online, and is useful when you need to normalize resource references or gather the minimal data required to connect a resource to other services. Recent updates improved the documentation and added basic support for ibb.co images while continuing to expand recognition of well known IDs and formats.

Dist::Zilla::PluginBundle::RSRCHBOY is a ready-made Dist::Zilla bundle that captures the author RSRCHBOY's preferred distribution build, test, metadata and release setup so you can apply his conventions by adding [@RSRCHBOY] to your dist.ini. It assembles a curated set of plugins for things like metadata generation, POD weaving and stopwords, test helpers, Git and GitHub automation, release signing and post-release install steps, while allowing you to tune bundled plugins by passing Plugin::Name.option entries in dist.ini. If you want to inspect exactly what it will do first, the companion Dist::Zilla::App::Command::dumpphases makes the phases easy to review. The bundle is actively maintained and configurable via options such as sign, tweet, github and install_on_release, and note that recent behavior in version 0.078 defaults to not tweeting or signing releases; report bugs or feature requests on the project's GitHub issue tracker.

Sim::OPT is a Perl toolkit for steering and automating parametric optimization and exploration workflows that drive text‑based simulation models. It helps you generate and morph input files, run batches of simulations, and search a multidimensional parameter space using overlapping block searches that mix sequential and parallel update strategies, with options for factorial, star, face‑centered composite designs and metamodel‑based searches. The framework can operate by launching simulations or by mining precomputed results, records clear instance naming and mapping for traceability, and includes utility modules for model morphing and specialized tasks such as ESP‑r shading tweaks, creating AutoCAD 3D plots from parallel coordinates, and building sparse-data metamodels. The distribution provides an "opt" entry command, example workflows for ESP‑r and EnergyPlus, and runs on Linux. Sim::OPT is dual licensed with the open source copy available on CPAN under GPL v3 and additional proprietary components offered by the author, and the changelog in this release contains the original packaging metadata.

Catalyst::Plugin::Session::Store::DBIC lets you persist Catalyst web application session data directly in a database using DBIx::Class, making it easy to plug sessions into your existing DBIC models without writing custom storage code. It acts as a thin wrapper around Catalyst::Plugin::Session::Store::Delegate, so you get straightforward mapping of session id, data and expiry fields to a DBIC result class while still being able to fall back to the Delegate module for more advanced control. Configure it by naming the DBIx::Class result source (dbic_class) and optional field names for id, session_data and expires, and be aware that session data is MIME::Base64 encoded and can trigger warnings if your database column is too small so use MEDIUMTEXT or larger for heavy sessions in MySQL. The module does not auto-clean expired rows so you should run delete_expired_sessions periodically or via a scheduler. Recent fixes addressed a bug where changing a session id could produce a “row not found” error, so upgrading to the latest release is recommended.

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.

Net::WoRMS is a small Perl wrapper around the World Register of Marine Species (WoRMS) SOAP API that powers the query-worms utility, providing web access, parsing and simple output formatting through a Moo object and SOAP::Lite. It exposes easy-to-use methods to search species by name, fetch a taxon record by AphiaID, page through child taxa and print results in TEXT, CSV or SQL formats, and it includes a debug mode and hooks to change the SOAP endpoint, namespace and output format before initialization. The module is aimed at developers who need quick, scriptable access to WoRMS data from Perl or command-line tools and favors simple integration over heavy abstraction. Recent work focused on documentation polish and CPAN deployment fixes so installation and usage should be more straightforward; the module does depend on SOAP::Lite and a small Moo-based type layer.

App::GHGen is a command line tool that generates, checks, and optimizes GitHub Actions workflows so you can add or maintain CI with minimal effort. It can auto-detect your project type or let you choose from templates for Perl, Node, Python, Rust, Go, Ruby, Docker, and static sites, then produce opinionated workflows with dependency caching, concurrency controls, proper permissions, and common lint and coverage steps. It also analyzes existing workflows for performance, security, cost, and maintenance problems, offers cost estimates, and can safely apply fixes or open a pull request with suggested changes; it can even run inside GitHub Actions to comment on PRs or act as a CI quality gate. Perl projects get special attention with multi-OS and multi-version matrices, smart minimum-version detection, CPAN caching via local::lib, cross-platform syntax checks, optional Perl::Critic and coverage, and sensible defaults that you can customize. If you want to reduce CI minutes, keep Actions secure and up to date, or automate workflow maintenance across many repositories then this tool is likely relevant. The recent 0.08 release bumps the Perl setup action and fixes analyzer false positives around outdated runner detection while tightening matching logic and aligning analyzer and fixer rules so flagged issues are reliably fixable.

OpenAPI::Modern is a Perl library for validating HTTP requests and responses against OpenAPI v3.0, v3.1 and v3.2 documents, letting you check that incoming or outgoing traffic conforms to your API specification and extract deserialized parameter and body data for further use. You build an OpenAPI::Modern object from an OpenAPI document or schema and it uses JSON::Schema::Modern to perform fully standards‑compliant JSON Schema evaluation, returning a rich result object that contains validation errors, populated data, and optional default values. The module is designed to work natively with Mojolicious request and response objects and will convert common request/response types from other frameworks on a best effort basis while also offering helpers to locate operations, resolve $ref chains, and cache parsed documents for faster startup. It bundles the official metaschemas and supports content encodings, multipart/form-data and media type based parameter deserialization, and includes debug hooks to help trace matching and decoding. Note that some niche OpenAPI features are not implemented and there are caveats around parameter percent‑encoding, certain multipart types, and automatic verification of Authorization headers, so review the documented limitations if you rely on those behaviors.

Net::SAML2 is a Perl library for implementing the Service Provider side of SAML 2.0 Web Browser Single Sign On, letting your application create AuthnRequests, sign and verify Redirect and POST bindings, process responses from Identity Providers, decrypt EncryptedAssertions and generate or consume metadata. It is mature and widely tested against providers such as Auth0, Microsoft Azure, Google GSuite, Okta, Keycloak, ADFS and Shibboleth, and supports both signing and signature verification workflows. Recent releases harden security by requiring a trust anchor (cacert or cert_text) for Response and Assertion verification, add defenses against XML signature wrapping, and fix several CVEs, so upgrading is recommended. Note that Net::SAML2 is SP-side only and expects XML metadata from the IdP.

File::Rotate::Simple is a lightweight, no-frills Perl utility for rotating files by renaming them with numeric suffixes so you keep a simple set of backups. It can increment existing rotation numbers, limit kept files by count or by age in days, and is usable via an object interface, a legacy method call, or an exported function for quick scripts. You can customize the starting number, apply timestamped extensions using strftime with a special %# placeholder for the rotation number, replace or append extensions to preserve original suffixes, and optionally touch the file after rotation. The time attribute accepts Time::Piece and, since v0.4.0, DateTime::Lite and DateTime::Tiny objects. The module intentionally keeps behavior simple and does not track or fill gaps in rotation sequences. Recent changes include enhanced time object support and a security fix to avoid touching destinations of dangling symlinks when rotating (CVE-2026-17435). Note that current releases require Perl 5.14 or later and older Perl users should use the v0.2.x series.

Params::Get provides a single helper, get_params, that turns whatever a Perl caller might hand your subroutine into a consistent hash reference so you can write one simple normalisation call at the top of each public method instead of reimplementing argument parsing over and over. It understands the common Perl styles including a lone hashref, named key/value pairs, a single scalar tied to a default key, an arrayref shorthand or \@_, scalarrefs, CODE refs or blessed objects, and an arrayref of positional key names, and it pairs nicely with Params::Validate::Strict and Return::Set to enforce input and output contracts. The function returns a hashref on success or undef in the documented empty case and will croak or confess on misuse so bugs are reported from the caller frame. Be aware of a few documented limitations such as the fast-path that treats a single hashref as the hash rather than as a value for a default key, ambiguity when a caller passes a single empty arrayref, silent overwriting of duplicate keys in flat lists, and the lack of a way to mark a scalar default as optional. The current 0.16 release tightens edge-case handling, removes some redundant checks, improves performance of common paths, and adds extended security and unit tests.

Perl::Tidy is a module that brings the perltidy formatter into your Perl programs so you can parse, beautify, and analyze Perl source from code rather than the command line. You can feed it files, strings, arrays or stream objects and capture output, errors and logs, pass command-line style options or a perltidyrc, and hook in prefilters, postfilters or a formatter callback to inspect tokenized lines for custom processing. It is useful for editors, linters, automated formatting in build and CI systems, or any tool that needs to rewrite or report on Perl code while preserving control over encoding and error handling. The distribution is mature and actively maintained and the 20260808 release fixes a rare tokenization instability around an eval/map pattern and improves here-doc handling and related warnings, making the formatter more robust for tricky edge cases. The module is distributed under the GNU General Public License.

Imager::Font::W32 brings Windows GDI font rendering to the Imager image library so Perl programs on Win32 can draw text using native Windows fonts. You obtain a font with Imager::Font->new specifying type => "w32" and then pass that font to Imager methods like string to render text onto images. It is intended for Windows-only use when you want native font appearance and metrics in generated images. Note that the module was renamed after older Imager releases could mistakenly report Win32 font support when an unrelated Win32.pm was present.

Imager::Font::FT2 is the FreeType 2 based font backend for the Imager image library that lets you load TrueType and other FreeType-supported fonts and draw text into images via Imager::Font (for example, Imager::Font->new(file => "foo.ttf", type => "ft2")). It is intended for anyone using Imager who needs reliable font rendering, including anti-aliased and non-aliased text, glyph names and related font queries, and relies on the system FreeType 2 library at build and runtime. The module has had a few packaging and build fixes to improve compatibility with newer FreeType releases and toolchains and to clean up warnings and memory-test issues, and there is a historical caveat that older Imager releases used a different module name which could confuse probe logic on systems without FreeType installed. If you use Imager and need robust font support from the system FreeType implementation, this module is the appropriate backend to choose.

Imager::File::TIFF integrates libtiff support into the Imager framework so Perl programs can read and write TIFF images, typically by calling Imager->read or Imager->write; it also provides class methods to list available TIFF compression codecs with their numeric ids and names and to report the libtiff build date, build version and runtime library version, which helps when choosing compression options or diagnosing compatibility.

Imager::File::PNG provides PNG image read and write support for the Imager toolkit, letting you load and save PNG files (including paletted, interlaced and 16‑bit/sample images) through Imager in a straightforward way. It exposes low level class methods to read and write PNG data from Imager::IO objects, which are useful for related formats that encapsulate PNG such as APNG or ICO and for other advanced embedding scenarios. The module also supports metadata handling and lets you control things like zlib compression level when writing files. Recent updates cleaned up build warnings and refreshed the bundled Devel::CheckLib helper to improve compatibility and compilation robustness.

Imager::File::JPEG is the Imager extension that adds robust JPEG read and write support to the Imager image toolkit, letting Perl programs load, save and control JPEG images from within Imager. It exposes high-level controls for common JPEG features such as progressive output, optimization, subsampling, smoothing and restart markers and it also surfaces more advanced libjpeg-specific knobs including arithmetic coding, JFIF header control and mozjpeg tuning and compression profile settings. The module reports which libjpeg variant it was built against and its version, and provides helpers to detect libjpeg-turbo or mozjpeg and whether encoding or decoding of arithmetic coding is supported so you can adapt behavior to the available library. It integrates EXIF and IPTC handling via Imager and the recent releases include security and stability fixes, including patched EXIF parsing issues and a memory-leak fix, making it suitable for projects that need reliable, configurable JPEG handling in Perl.

Imager::File::GIF is the GIF reader and writer plugin for the Imager Perl image library, letting Perl scripts load and save GIF images through the Imager object model. It plugs into Imager so you can use familiar Imager methods to handle GIF files, and detailed options and behavior are documented in Imager::Files. Use this module when you need simple, integrated GIF input/output support within Imager-based image processing.

Imager is a mature Perl image library for creating, manipulating and saving full color images in a wide range of formats. It makes common tasks easy from simple scripts such as resizing or thumbnailing to more advanced work like drawing primitives and text, alpha blending, color conversion, filtering and matrix transforms, and it can read and write PNG, JPEG, GIF, TIFF, ICO/CUR and many other formats via optional format handlers. You work with image objects created by Imager->new, call methods such as scale, crop, filter, paste and string, and then write the result to disk, so it is a good fit for web backends, batch image processing and small graphics tools where you want direct control from Perl. The project is actively maintained and recent releases include important security and robustness fixes to EXIF/JPEG/GIF/TIFF handling, so upgrading to the latest version is recommended.

Search::Trigram is a compact, in-memory trigram inverted-index for Perl that makes it easy to add UTF-8 documents and run fast fuzzy or substring-style searches. You add texts and get back numeric ids, then search with a query string to receive a ranked list of matches scored by the Dice coefficient over shared trigrams, with case-insensitive matching at the byte level and a default result limit of 10. The module supports marking documents deleted and reclaiming space with an optimize call, clearing the whole index, and querying counts of live documents and distinct trigrams. For extension authors there is a documented C ABI so other XS code can drive the same index without a Perl frame, and the ABI is designed to avoid cross-module memory and ownership pitfalls by keeping object lifetime in Perl and returning borrowed text pointers that are invalidated on mutation.

Catalyst::View::ChromePDF is a Catalyst view that renders HTML or Template‑Toolkit output to PDF by driving Chrome or a Chrome‑compatible browser through WWW::Mechanize::Chrome, making it a modern replacement for Catalyst::View::Wkhtmltopdf. You configure it in your app and stash a pdf hash with either a template or raw HTML and options like page size, orientation, download disposition and filename, or you can pass an existing mechanize instance or chrome launch arguments. It intentionally mirrors familiar wkhtmltopdf settings where possible while noting some differences such as lowercase orientation and the need to supply Chrome launch executable via chrome_args, and it currently does not support margins, DPI, or image quality options. Be aware that temporary HTML and PDF files are written to tmpdir and may remain after failures or when returning filehandles so you should arrange periodic cleanup for sensitive data. The module requires Perl 5.24 or newer and the source and issue tracker are on GitHub.

Lingua::famibeib is the top-level Perl module for working with famibeib, an artificial language, and serves as the entry point to a small ecosystem of helpers for parsing, manipulating, and generating famibeib text. It ties together submodules that focus on text handling, sentence-level operations, and word-level details while integrating with Data::Identifier so words and modifiers can be registered and discovered. The distribution includes practical features such as number-word parsing, main-verb resolution and other grammar-aware utilities, and it also provides experimental tools like a proper-name generator and visual markers for words in display modules. Recent updates added a Wellknown helper module, IDE annotations, improved verb and adjective parsing, and support for registering generators, making the package convenient for developers building parsers, generators, or language tooling around famibeib.

Sidef is a modern, multi-paradigm programming language packaged as a Perl module so you can embed, compile, optimize, and execute Sidef code from Perl and reuse the entire CPAN ecosystem. It blends object-oriented and functional features with a rich numeric type system that includes arbitrary-precision integers, rationals, floats and complex numbers, and it offers conveniences like pattern matching, lazy evaluation, multiple dispatch, a REPL, AST-level parsing and transformation, and the ability to compile Sidef to readable Perl for inspection or high-performance deployment. The module supports multi-level optimization and optional DBM-backed caching to speed repeated runs and can use GMP/MPFR/MPC or optional Math::GMP* libraries and a PARI/GP backend for heavy numeric workloads. If you embed Sidef expect some operational details to consider such as required native math libraries for best performance, the DBM cache not being thread-safe without external coordination, and Unicode behavior relying on Perl itself. Note in the recent 26.08 release there is a breaking change: the regex union operator now performs alternation rather than concatenation, so patterns using the old behavior may need updating.

DBIx::Loop provides a non-blocking wrapper around DBI so you can run database work without stalling an event loop. It exposes a future-based API where query and do return futures that integrate with your event loop via a small adapter for IO::Async, Mojo::IOLoop, AnyEvent and others. At connect time it chooses one of two backends: a universal worker pool that runs blocking DBD calls in separate worker processes and works with any DBD including SQLite, or a native file-descriptor async path for DBD::Pg that drives libpq directly and avoids worker serialization. Results come back as simple structures so query yields rows as arrayrefs plus a columns list and do yields rows_affected and an optional insert_id. Transactions are supported and pinned to a single connection so you can run BEGIN and COMMIT safely inside the async model. DBIx::Loop is not an event loop itself so you must supply an adapter, and its goal is latency isolation and concurrency rather than raw per-query speed. If you run an event-driven server and need a straightforward future-based way to use DBI without blocking, this module is likely a good fit.

CPAN::MetaCurator is a maintenance toolkit for the cpan.metacurator.sqlite database that helps you curate and publish CPAN metadata and Perl wiki content. It bundles utilities to prepare wiki content, export Perl.Wiki.html, convert those exports into a jsTree-friendly structure for web presentation, rebuild the Perl Wiki tree, patch an index.html and upload the results, and it converts Changes into a machine-readable Changelog.ini via Module::Metadata::Changes. The distribution follows a simple versioning rule where versions below 1.00 are development and 1.00 and up are production, and it is maintained by Ron Savage with source and issues tracked on GitHub and RT. The code is released under the Perl 5 license and is intended for anyone who needs a practical, open source way to manage CPAN metadata and publish Perl wiki content.