CPANscan

Amazon::S3::Lite is a compact, dependency-light Perl client that covers the S3 operations most commonly needed in AWS Lambda functions and small scripts. It provides easy APIs for listing buckets and objects, reading and streaming objects to disk, checking metadata, uploading from scalars or filehandles, copying and deleting objects, creating buckets, and configuring SQS or Lambda notification targets. Built on HTTP::Tiny and Amazon::Signature4::Lite it avoids LWP to keep package size and cold-start overhead small and supports credential discovery and rotating IAM/Lambda credentials via an optional credentials object or environment variables. Responses are returned as parsed Perl hashrefs to simplify common tasks and the module intentionally leaves out advanced S3 features like multipart uploads, presigned URLs, ACLs, and versioning so you should use Amazon::S3 or Net::Amazon::S3 if you need the full API. The recent 1.2.0 release added a remove_bucket_notification_configuration method to let you clear bucket notification settings.

Stats::LikeR is a Perl library that brings a broad suite of R-like statistical tools and data-frame utilities to Perl with an emphasis on speed by using XS implementations. It provides basic summaries and distributions, correlation and covariance tools, many hypothesis tests (t, wilcoxon, kruskal, chi-squared, Fisher, KS), linear and generalized linear models, PCA, and resampling and power utilities, together with data-frame primitives for reading, writing, viewing, filtering, sorting, grouping, transposing and reshaping tables in the common AoH/HoA/HoH shapes. Many functions are forgiving about input shapes and will coerce or transpose data to match your target structure, while others validate and die on undefined numeric values to avoid silent errors, and several behaviors around formula expansion and CSV round-tripping are documented limitations. If you want an R-style workflow inside Perl and need high performance on medium to large datasets, Stats::LikeR is a practical, feature-rich choice.

Time::Spec is a tiny, practical Perl object that represents a time value as whole seconds plus nanoseconds, effectively wrapping a C struct timespec for use from Perl. You can construct it from a fractional seconds value or from a seconds/nanoseconds pair, read the sec and nsec parts, convert back to a floating seconds value or to the original pair, and it will behave like fractional seconds when used in numeric context. It is most useful when you need subsecond precision or when writing or using XS/native extensions that expect timespec-like structures, and it is intentionally simple and lightweight rather than aimed at pure-Perl time handling.

Aion::Env makes it easy to expose project configuration from .env files and the process environment as read-only Perl constants, with optional type checking and default values. You declare a variable in your package using the module's import syntax and it will initialize the constant from %ENV, fall back to a .env file if the environment value is missing or undef, and finally use a supplied default. The module validates .env syntax and enforces types when you pass the isa option, and it also provides a parse function to load a .env file into a hash for other uses. This is the initial release of Aion::Env.

Time::Nanos gives Perl programs easy access to high-resolution timestamps by exposing the system clock_gettime interface so you can get nanosecond, microsecond, or millisecond readings via simple functions nanos, micros, and millis. nanos returns a total nanosecond count in scalar context and can return a two-element list of seconds and nanoseconds when requested. The module defaults to CLOCK_MONOTONIC so it is best for measuring elapsed time and profiling, and it also lets you choose 'realtime' if you need wall-clock-style values while warning that realtime can jump or skew with system clock changes and may rarely yield negative differences. Use this module when you need simple, high-resolution timing in Perl rather than full calendar time.

Apache2::API is a convenience framework that wraps the mod_perl2 Apache API to make building HTTP handlers and JSON APIs simpler and less error prone. It centralises common tasks like request and response objects, JSON encoding and decoding, character set and URL handling, content compression, logging, server-sent events, UUID generation and htpasswd style password hashing, and it also exposes Apache constants and helper methods to read handlers and server details. The module is aimed at developers writing mod_perl-based web services who want a consistent, higher-level toolkit instead of juggling many low-level Apache2 calls. Recent releases include a security fix that removed an insecure rand() fallback for salt generation in the password code so a secure random provider such as Crypt::URandom or Bytes::Random::Secure is now required, and a dependency update for DateTime::Lite in the latest minor release.

DateTime::Calendar::Christian extends the DateTime system to represent historical dates across the Julian-to-Gregorian switch so you can create and manipulate dates that fall before, during, or after the reform used in different countries. You instantiate it with a reform_date (a DateTime, a named location like "UK", an array, or an ISO-style string) and the object will tell you whether a date is Julian or Gregorian, report leap years, day-of-year, days-in-year, and perform arithmetic that respects the calendar change so anniversaries and month/year adjustments behave sensibly across the reform. It integrates with DateTime methods such as from_epoch and from_object and supports serialization and overloaded comparisons. Be aware of some caveats around the reform year and skipped dates: a skipped date is currently assumed Gregorian and converted to Julian, dates that could be both calendars may be treated as Julian, and reform dates before 200 AD or after about 4000 AD can produce duplicated or missing dates. Overall it is the right choice when you need historically aware calendar calculations spanning the Julian and Gregorian systems.

DateTime::Calendar::Julian is a DateTime-compatible module that represents dates in the Julian calendar and lets you create, manipulate, and convert Julian dates alongside normal Gregorian DateTime objects. It implements the standard DateTime API so you can construct Julian dates, get year/month/day/time values, and convert to or from Gregorian DateTime objects for comparison or display. The module uses a proleptic Julian calendar for very early dates and represents BC years with negative numbers and year zero as 1 BC, so it is suitable for historical and astronomical work where the Julian reckoning is required. It also provides convenience methods like gregorian_deviation and calendar_name and recent releases added support for quarter-related methods while updating DateTime version requirements to ensure modern interoperability.

Geo::WebService::Elevation::USGS is a lightweight Perl client for querying the USGS Elevation Point Query Service to get the elevation at a given latitude and longitude. You call elevation() with numeric coords or a Geo::Point-like object and get back a hashref containing the elevation (in feet or meters), source info and coordinates, with options to round results, control timeouts, retry logic, rate-throttle requests, and choose whether the module croaks on errors or returns undef and records the error. The module documents that horizontal coordinates are WGS84/NAD83 and vertical elevations are drawn from the NED/NAVD88 datum, handles occasional upstream URL and API changes by exposing the service URL as an attribute, and has deprecated legacy "compatibility" behavior tied to an older GIS service. Recent updates moved the client to the USGS epqs v1 JSON endpoint and tests now allow small variations in returned elevations because the remote service can vary slightly.

Aion is a Perl 5 object system in the Moose/Moo family that gives you a compact, feature-rich way to declare classes, roles and properties with a familiar has/with syntax and rich aspects like is, isa, default, lazy, coerce, trigger, release, clearer and predicate. It includes method signature checking via the :Isa attribute, lets roles add their own aspects, and supports dependency injection through its eon/pleroma mechanism so you can wire services into features. Aion also ships a flexible type system that accepts strings, coderefs and callable objects and supports coercions and parametrized types. The recent 2.0 release significantly expanded the type machinery with unions, ranges, subtype variables, new comparison and set operators, coercion prototypes and cached type testers for better expressiveness and performance. Use Aion if you want a modern, extensible, runtime-typed Perl OOP framework that stays lighter than full Moose but still offers advanced validation and DI capabilities.

Net::RDAP is a Perl library that provides a straightforward, unified interface to the Registration Data Access Protocol, the modern replacement for Whois, allowing you to look up domain names, IP addresses or ranges, and autonomous system numbers as well as fetch entity and nameserver records. The module handles server discovery via the IANA registry, performs the HTTP queries and JSON parsing for you, and returns rich objects representing domains, IP networks, autnums and entities, while also offering a Service class for issuing server-side searches. It supports optional on-disk caching with configurable TTL and storage location, lets you set Accept-Language or supply basic auth when directly fetching resources, and exposes the underlying HTTP user agent so you can configure cookies, proxies and custom headers. Internationalized domain names must be converted to A-label/Punycode before lookup. The Net::RDAP distribution bundles a suite of supporting modules for registry access, object parsing and error handling and is actively maintained on CPAN.

CryptX is a comprehensive Perl cryptography toolkit that bundles LibTomCrypt and LibTomMath and exposes a consistent family of modules for encryption, authenticated encryption, hashing, message authentication, secure random data and UUIDs, key derivation, and public key operations. It serves as the distribution entry point rather than a single API, so you pick the concrete module you need, for example ChaCha20-Poly1305 or XChaCha20-Poly1305 for AEAD, Crypt::PRNG for secure randomness, Crypt::Digest for hashing, Crypt::Mac for MACs, Crypt::KeyDerivation for password hashing, and Crypt::PK for signatures and key agreement. The documentation includes practical algorithm guidance and sensible defaults, noting ChaCha20-Poly1305 as the recommended AEAD and AES as the default block cipher where hardware acceleration matters, and it also flags legacy or insecure items such as RC4 being provided only for interoperability. CryptX provides diagnostic helpers to inspect the bundled build and ships Math::BigInt::LTM as a big integer backend; most modules report errors by croak while AEAD decrypt/verify helpers return undef on authentication failure. The distribution is free software and intended for developers who need a broad, well-documented set of cryptographic building blocks in Perl.

Muster is a Perl-based content management web application built on the Mojolicious framework that aims to help you "muster your pages" with a lightweight, developer-oriented CMS layer. It integrates with Mojolicious::Plugin::Foil and is intended for Perl developers who want a simple, framework-native way to manage site content and media without adopting a heavy external system. The project is actively maintained and recent releases have focused on robustness, with fixes for a race condition, improved error checking, and refinements to EXIF image metadata parsing in the current 0.9501 release. If you are building a Mojolicious application and need an embedded CMS with basic page and media handling, Muster is worth a look.

App::Greple::xlate adds translation capabilities to the greple search tool so you can find specific parts of files and replace them with machine translations from engines like DeepL, OpenAI GPT-4.1 and GPT-5. It highlights matched regions, supports configurable output formats such as git-style conflict markers or simple translated-text output, and can operate on whole files or only selected patterns so you can review changes before applying them. The module includes normalization and masking features to preserve code, markup, or other fragments you do not want translated, and it supports per-engine options like DeepL glossaries or custom prompts and context for ChatGPT models. A cache reduces repeated API calls and there is a manual clipboard workflow if you prefer to_translate by hand, plus Docker and Emacs integration to simplify environments and workflows. Overall this is a practical tool for selectively translating documentation or source comments while keeping original and translated content clearly separated for review and merging.

MARC::Validator is a small, plugin-based toolkit for checking MARC metadata records for common problems, such as malformed ISBNs, duplicate or missing fields, incorrect field contents and a range of field-specific rules (008, 020, 035, 040, 045, 080, 300, 500, 504, 655 and others). It exposes a simple discovery API so you can enumerate and load the available validator plugins and integrate their checks into your cataloging or ingest workflows. The module relies on Module::Pluggable and focuses on producing actionable validation reports rather than performing fixes, and recent releases have tightened checks around the 080a UDC field (catching bad dots, apostrophes and quotation marks) and added support for a new date_entered_on_file check.

SPVM::File::Spec provides a simple, cross-platform API for building, parsing and manipulating file paths in SPVM. It is a thin wrapper that forwards calls to a singleton File::Spec::Instance which in turn dispatches to platform-specific implementations like Unix or Win32. You get familiar utilities to concatenate path components, split directories and filenames, canonicalize paths, convert between absolute and relative paths, and retrieve system-specific values such as the current directory, root, temporary directory and null device. This module is a port of Perl's File::Spec and is useful whenever you need predictable, portable filename handling across different operating systems in SPVM programs.

Encode::BetaCode is a small Perl utility for converting between Beta Code and Unicode, aimed at people working with classical Greek texts and legacy encodings. It provides two main functions, beta_decode to turn Beta Code into Unicode and beta_encode to go the other way, and it supports both plain Greek and a punctuation-aware variant. The encoder understands combined characters and offers output styles compatible with the TLG and Perseus conventions, making it useful when importing or exporting corpora from those resources. Functions are not exported by default but can be brought in with ":all". The module is actively maintained with source on GitHub and a bug tracker on CPAN for reporting issues.

Plack::Handler::H2 is a high-performance HTTP/2 server handler for Plack and PSGI that lets you run your Perl web apps with native C++ HTTP/2 support through XS bindings. It is intended to be run with plackup and uses industry libraries like nghttp2, libevent and OpenSSL to provide TLS with ALPN, stream multiplexing, header compression, asynchronous I/O and server push. The handler is PSGI compliant and supports streaming and delayed responses, automatic buffering of request bodies, and easy development use with auto-generated self-signed certificates while allowing real CA certificates for production. It requires native libraries and a modern C++ compiler and is not supported on Windows, so it is a good fit when you need production-grade HTTP/2 performance for existing PSGI frameworks or custom PSGI applications.

Spreadsheet::ParseXLSX is a lightweight adapter that lets Perl programs read Excel .xlsx files using the familiar Spreadsheet::ParseExcel API, so you can parse workbooks, worksheets, and cells with the same objects and methods you already know. You create a parser, call parse on a filename or filehandle, and get back a Spreadsheet::ParseExcel::Workbook instance, with optional password support for encrypted files. The module normalizes colors to RGB strings and provides basic formula support by exposing the formula text in the cell data, though formula results are only available if they were saved in the file. It aims to be a drop-in replacement for XLS support but has a few practical limits: large files can trigger a segfault on older Perl releases because of an XML::Twig bug, worksheets missing a dimension tag are not supported, intra-cell formatting is discarded, and shared formulas are not implemented. The project is actively maintained on GitHub and is MIT licensed, so it is a good choice if you need straightforward XLSX reading without changing the rest of your Spreadsheet::ParseExcel-based code.

Mojolicious::Plugin::Fondation::MigrationDBIx is a plugin that brings integrated database migration and fixture management to Mojolicious apps using DBIx::Class backends via Fondation::Model::DBIx::Async. It adds a simple "db" command set so you can bootstrap a Schema class, generate migration SQL from your Result classes, apply or step migrations, inspect migration status, and load fixture data packaged by your app or its plugins. The plugin discovers and copies fixtures from any loaded Fondation plugin into your application's share directory, detects the database driver from the DSN, and uses DBIx::Class deployment tools to produce upgrade and downgrade SQL on the fly. A helper reports schema drift between prepared migration files and the live schema to help catch out-of-sync updates. You can target a specific DBIx::Async backend or a custom migrations directory via configuration. This initial release provides the core commands for preparing, installing, checking status, and populating fixtures, making it a convenient choice if you want lightweight, filesystem-based migrations and plugin-aware fixtures in the Fondation ecosystem.

IO::Compress is the umbrella Perl distribution for reading and writing compressed data in many common formats. The file shown here is a stub with no code, but the IO::Compress family (for example IO::Compress::Gzip, ::Zip, ::Bzip2 and the matching IO::Uncompress::* modules) provides simple procedural and object interfaces for compressing and uncompressing streams, files and in-memory buffers, with support for streaming operation, automatic format detection, Zip features like Zip64 and extra fields, and a wide set of compression back ends including gzip, bzip2, lzma/xz and zstd. The distribution is actively maintained by Paul Marquess and recent updates (June 2026) include refreshed zip metadata tooling and portability improvements such as better EBCDIC handling and wildcard fixes. If you need robust, cross-format compression support in Perl, the IO::Compress modules are the ones to use.

App::zipdetails supplies a simple command line utility for inspecting the internal structure of ZIP archives, letting you peek at headers, directory entries, compression methods, stored sizes and offsets so you can debug, verify or learn about how a ZIP file is laid out. The CPAN distribution primarily provides a stub module that installs the zipdetails script, so consult the bin/zipdetails script for usage and options if you want to run it.

Mojolicious::Plugin::Fondation::Model::DBIx::Async is a Fondation plugin that gives Mojolicious apps native, nonblocking access to DBIx::Class via DBIx::Class::Async so you can run DBIC queries without blocking the event loop. You configure one or more backends (each with a DSN and schema class) and named models that map to table sources, and the plugin exposes simple helpers like schema_class, schema and model to get async DBIC ResultSet objects that return Future objects for queries and DML. Workers are forked into a background pool per backend on first use so the web process stays responsive, Result and ResultSet classes from plugins are auto-registered, and shutdown triggers graceful disconnects of worker pools. Note that async calls return Future chains and you should call ->retain to avoid premature garbage collection of the promise. This initial release provides the schema, schema_class and model helpers and the basic backend and model plumbing to integrate DBIx::Class::Async into Fondation-based Mojolicious apps.

Pod::Coverage::TrustMe checks that the functions and methods a Perl package provides are documented and extends the familiar Pod::Coverage workflow with practical extras for real projects. It lets you mark subs as private with regexes or literal names, explicitly trust individual methods as documented even without POD, pull documentation coverage from parent classes, roles, or other packages, honor in-POD Pod::Coverage lists, require nonempty documentation sections, restrict checks to exported symbols, and ignore imported subs so helper imports do not force you to document them. The module reports coverage as a percentage, lists covered and uncovered symbols, and can produce human readable reports for tests or CI. It uses Pod::Simple instead of the old Pod::Parser, avoids providing an import hook, and is designed to be subclassed for custom symbol or POD discovery. If you run documentation coverage checks in your test suite or want stricter control over what counts as documented API, this module is a drop-in, more flexible replacement for Pod::Coverage. A recent maintenance update fixed option forwarding when using all_pod_coverage_ok in test harnesses.

Amazon::API is a lightweight, generic Perl base class that makes it possible to call AWS services without a full SDK. You can use it directly as a DIY gateway, subclass it with a small list of methods, or generate complete, documented service classes and data shape serializers from Botocore metadata using the included amazon-api tool. It handles signing, multiple content types and protocols, credential discovery via Amazon::Credentials, automatic pagination for Botocore-based calls, and optional response decoding so you normally get Perl data structures rather than raw XML or JSON. The module favors small deployments and targeted use of single services and will return raw responses instead of failing when serialization has edge-case problems unless you enable stricter error behavior. It is not a drop-in replacement for a full SDK like Paws and some services such as S3 are better served by dedicated modules, but if you want a simple, scriptable way to call only the APIs you need this module is a good fit. Recent updates added a --localstack option and improved Botocore serialization and response unwrapping, and the latest 2.2.4 release fixed URL encoding for the top-level Version key in query content.

DateTime::Fiction::JRRTolkien::Shire is a DateTime-compatible Perl calendar class that models the hobbits' Shire calendar from Tolkien's Lord of the Rings, letting you represent dates with twelve 30-day months plus the five special holidays and a sixth holiday in leap years. It plugs into the DateTime ecosystem so you can construct dates from epochs or other DateTime objects, compare and stringify them, do date math with a custom Shire duration class, format with a Shire-aware strftime, and retrieve week, quarter, holiday and day-of-week information while handling Shire-specific rules such as Midyear's Day falling outside any week. The module intentionally uses a Gregorian-style leap-year rule to keep years aligned with our calendar and preserves time and locale attributes for conversion to other calendars, though format_cldr() is not implemented. Recent maintenance improved documentation, tests and metadata and added CONTRIBUTING and SECURITY files along with small fixes and examples.

Date::Tolkien::Shire is an object oriented Perl module that converts standard epoch or calendar dates into J.R.R. Tolkien's Shire Calendar and gives you friendly ways to inspect and format them. You can build a Shire date from epoch seconds or from Shire year/month/day or holiday values, convert back to epoch midnight, query the Shire year, month, day, holiday and weekday using either modern or traditional names, and compare dates with normal numeric and string operators. It includes a strftime-like formatter and an on_date method that returns themed historical events from The Lord of the Rings, plus options for accented or traditional output. The module intentionally matches modern leap year rules so common dates map sensibly across eras, and its methods favor safe error reporting rather than dying on failure. Note that because it currently relies on epoch time it may be limited by your system's epoch range, which can restrict very old or very future dates on some platforms.

Date::Tolkien::Shire::Data provides the core utilities for handling J.R.R. Tolkien's Shire calendar and is the shared implementation used by Date::Tolkien::Shire and DateTime::Fiction::JRRTolkien::Shire. It models a calendar of twelve 30-day months plus five or six intercalary holidays, including two days that are not part of any week, and supplies routines to convert between month/day, day-of-year and Rata Die, compute leap years, weekday and week numbers, quarters, and to translate month and holiday names and abbreviations. The module also offers a rich strftime-style formatter extended with %E patterns and padding flags to produce Shire-specific names and holiday-aware output, plus lookup and search functions that return the Appendix B event text for particular dates. It is subroutine-based, provides export tags and manifest constants for common holiday identifiers, and is intended mainly as a shared backend for the higher-level modules rather than as a standalone interface. Support comes from the author and bug reports are handled on the project GitHub.

Perl::Critic::Policy::Misc::ProhibitMethodsInStringConcat is a lint rule for Perl that flags method calls used directly inside string concatenation with the "." operator because if a method returns undef Perl's warning does not identify which call produced the undef, making the resulting bug difficult to track down. It encourages you to assign method results to named scalars first or to use sprintf/printf so diagnostics can point to a specific variable or keep template and values separate. The policy also digs into parenthesized subexpressions and will flag inner concatenations used with ".=" when they include method calls while allowing a single method as the sole right-hand operand of ".=". There are no configuration options for this policy.

Data::URIID is a helper for turning a URL, QR code payload, barcode or similar object into the identifiers and human-friendly metadata you need to display, link or integrate that resource in your application. You create an extractor, call lookup on a URI or supported object and get back a Data::URIID::Result that can provide canonical IDs, display names, icons, thumbnails and other attributes. The extractor supports both offline and optional online lookups, configurable user agent and preferred language tags, and accepts many input types including Data::Identifier objects and tag or file wrappers. It knows about a wide range of services (see Data::URIID::Service) and exposes utilities to map between well known names and ISE identifiers. Recent releases added wider identifier coverage and new service support including Denkxweb and initial ni:// URL handling, plus ongoing updates to the registry of known IDs. This module is useful if your app needs reliable, consistent identifiers or user-facing metadata extracted from URIs or codes.