CPANscan

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.

Crypt::OpenPGP is a pure-Perl implementation of the OpenPGP standard that lets Perl programs create and verify digital signatures, encrypt and decrypt messages, manage keyrings, and even generate key pairs without needing an external gpg binary. It exposes a simple high level API with methods such as new, encrypt, decrypt, sign, verify and handle, supports detached and cleartext signatures as well as ASCII armour, and offers compatibility modes for older PGP versions and GnuPG so you can interoperate with other implementations. The module supports common public key types and ciphers including RSA, DSA, ElGamal, 3DES, Blowfish, IDEA, Twofish, CAST5 and AES, plus MD5, SHA1 and RIPEMD160 digests and ZIP and Zlib compression, and provides features like MDC protection, passphrase callbacks, recipient callbacks and optional automatic key retrieval from an HKP keyserver. It requires a secure random source such as Bytes::Random::Secure or Crypt::Random and reports errors via errstr, and note that the key generation interface is labelled alpha. If you need to add OpenPGP capabilities directly inside Perl code or a web application, this module gives a comprehensive, portable toolkit.

Log::Report is a unified Perl framework for producing, routing and translating program messages so you can treat logging, exceptions and internationalization as one coherent system. It provides convenient message constructors like __, __x and __n that build lazily translated, interpolated message objects, a set of reasoned report levels such as trace, info, warning, error and fault, and a dispatcher system that sends each report to one or more back ends such as files, syslog or other logging frameworks with configurable modes like DEBUG or NORMAL. You can throw exceptions with familiar short helpers like error() and fault(), capture and inspect them with try(), and selectively control what gets processed with filters and the needs() test to avoid expensive work when unnecessary. Because translations are postponed until dispatch time, the same report can be logged in one language and shown to the user in another. The module also supports a lightweight Optional mode for low-overhead use inside libraries and offers domain-based configuration and tools to manage translation catalogs, making it a good fit for applications that need flexible routing, structured report reasons and multilingual output.

CallBackery is a Mojolicious-based framework for quickly building appliance-style web frontends that pair a Perl backend with a Qooxdoo JavaScript client. It provides ready-to-use wiring for configuration (default etc/callbackery.cfg or overridden via CALLBACKERY_CONF), a pluggable database object, RPC service namespace and controller, and application-wide security headers, and exposes a startup hook that mounts the Mojolicious app and routes. Use it when you want to deliver a rich single-page management UI driven by Perl without building the plumbing yourself. Note: a recent release switched the RPC layer to JSON-RPC 2.0, so you must use Qooxdoo 7.x and the matching Mojolicious::Plugin::Qooxdoo update and upgrade frontend and backend together.

Chemistry::OpenSMILES is a Perl toolkit for reading and writing SMILES chemical identifiers that follows the OpenSMILES v1.0 specification and is aimed at developers who need to convert SMILES strings into manipulable molecular graphs or produce SMILES from graph data. Its parser turns SMILES into Graph::Undirected objects where each atom is a Perl hash with fields for element, isotope, charge, hydrogen count, chirality and position, and its writer converts those graphs back to SMILES with a range of options to control hydrogen, aromatic and parentheses output. The module handles disconnected moieties, ring and cis/trans stereo, a variety of chiral types, valence calculations and aromaticity checks, and recent releases added explicit ring-detection utilities including rings() and can_be_aromatic_ring() to improve aromaticity handling. If you need a configurable, OpenSMILES-compliant SMILES reader/writer in Perl for cheminformatics tasks, this module provides a ready-to-use, well-evolved implementation.

Template::Sluz is a minimal Perl templating engine with a Smarty-like syntax that makes it easy to separate presentation from code in small to medium Perl projects. You instantiate it, assign scalars, arrays or hashes, and render templates from files with fetch or from strings with parse_string. The template language supports variable interpolation, chained modifiers and default values, if/elseif/else conditionals, foreach loops, include files, literal blocks and comments. A convenient feature is that any Perl built-in or user function can be used as a modifier so templates can call functions like ucfirst, join or substr with the template variable passed as the first argument. Its simple API and lightweight design suit cases where you want straightforward templating without a heavy framework.

CPAN::MetaPackager is a small utility for building and managing a local SQLite mirror of the CPAN package index, cpan.metapackager.sqlite, by converting the canonical CPAN package-list file (02packages.details.txt.gz) into a searchable SQL database. It is useful if you need a local, machine-friendly copy of CPAN metadata for offline querying, custom tooling, packaging workflows, or fast lookups without hitting the network for every query. The module is maintained by Ron Savage under the Perl 5 license and is production-ready at version 1.00 and above. Recent releases make it easier to keep the database current by downloading the latest 02packages.details.txt.gz and rebuilding the DB automatically, and include clearer instructions and timing information during import to help you monitor updates.

CPAN::MetaCurator is a toolkit for building, inspecting and exporting a local SQLite database of CPAN metadata derived from Perl.Wiki and related sources, with utilities to turn that data into a jsTree-style HTML site map and other reports. It bundles modules and command-line scripts to import 02packages.details.txt or CPAN::MetaPackager databases, gather and validate module and topic statistics, search for module names, and produce web-ready exports with clickable nodes and hover text. The project is aimed at maintainers who want to curate, rebuild or publish a browsable Perl module catalogue and includes validation and parsing helpers to keep the tree accurate. The latest release rebuilt the database and rewrote the usage instructions in MetaCurator.pm to simplify rebuilding and exporting workflows.