CPANscan

Tk::ListBrowser is a versatile Tk widget for Perl that presents collections of items as rows, columns, bars or hierarchical hlist/tree views with icons and text, and it provides sortable, resizable headers, optional side columns, keyboard and mouse navigation, multi or single selection, and instant filtering (Ctrl+F). You add items with add or itemCreate, adjust layout and appearance with many options (cell size, text wrapping, image placement and item type), switch arrange modes without losing data, and call refresh to rebuild the display while built‑in scrollbars and callbacks handle selection and double‑click actions. Recent updates improved performance, hierarchy handling, filtering, sorting and refresh behavior and added features like autorefresh, insert and refreshSingle plus indicator callbacks and better side‑column support. One caveat noted by the author is that custom fonts can slow refreshes appreciably, otherwise this is a full‑featured, actively maintained list browser for building icon- and text-rich list and tree interfaces in Tk apps.

Crypt::OpenSSL3 is a modern Perl wrapper that gives Perl programs direct access to OpenSSL functionality so you can perform SSL/TLS connections and a wide range of cryptographic tasks. It organizes features into focused submodules for SSL connections, asymmetric keys, symmetric ciphers, message digests, message authentication codes, key derivation functions, and X.509 certificate handling, while the top-level package provides simple error handling and build-time introspection so your code can query OpenSSL version and configuration details. Use this distribution when you need to integrate OpenSSL-backed crypto or TLS into Perl applications and want a compact interface to both runtime operations and metadata about the underlying OpenSSL build.

Astro::Coord::ECI is a core Perl class for representing and converting between the coordinate systems used in satellite tracking and basic astronomy, making it easy to turn NORAD/ECI positions into geodetic latitude, longitude and altitude or into local azimuth and elevation as seen from an observer. It is the foundation for subclasses that model the Sun, Moon, stars or satellites from TLEs and it also provides utilities for precession, nutation, equation of time, reference ellipsoids, Maidenhead locators, twilight and basic almanac calculations. Distances are in kilometers and angles in radians and the module can apply atmospheric refraction, return Doppler shift if a transmission frequency is set, and compute rise/set and pass times for observer locations, though the author notes velocity-related outputs are experimental and may be untested. If you need to predict satellite visibility, compute observer-relative coordinates, or build tools around TLE-based tracking this module and its TLE/Sun/Moon subclasses are directly relevant. Recent maintenance updates include refreshed canned magnitude data and a move to use the Celestrak API for magnitude lookups along with updated licensing and packaging details.

Astro::SIMBAD::Client is a Perl object for fetching data from the SIMBAD astronomical database (version 4) and for doing basic parsing of returned HTML, text, or VOTable output. You create a client object and can run URL-based queries, submit SIMBAD scripts, or use the older SOAP web service convenience methods, and the module can hand results to simple built‑in parsers or to user-supplied parser routines. It supports configurable defaults such as output format, parser, server and scheme, request delay to avoid overloading SIMBAD, POST versus GET for URL queries, and script handling options, and it includes a simple command‑line client and examples. Note that the SOAP interface is deprecated and may stop working, but the module can emulate SOAP calls by translating them into script queries via the emulate_soap_queries option; VO support relies on optional XML parsing libraries and SOAP use requires SOAP::Lite if you choose that path. This module is useful if you need programmatic access to SIMBAD lookup, reference, or coordinate queries from Perl and want an easy way to retrieve and parse the common output formats.

Astro::Coord::ECI::VSOP87D is a mixin module that brings the VSOP87D planetary position model into the Astro::Coord::ECI framework so you can compute accurate heliocentric ecliptic coordinates and velocities for the planets through Neptune. It is not used on its own but is designed to be mixed into subclasses of Astro::Coord::ECI or used via the distribution's ready-made subclasses for the Sun and the various planets, and it returns full state vectors while also providing utilities such as nutation (IAU 1980), obliquity, orbital period estimates, synodic period, and configurable model truncation to trade precision for speed. The implementation follows published VSOP87D coefficients and Jean Meeus examples and has been tested to closely match the Fortran reference and common ephemeris checks over the model ranges, so it is a practical choice if you need programmatic planetary positions within the stated temporal accuracy windows and want integration with the Astro::Coord::ECI almanac and coordinate conversion routines.

FacialHarmonyAI::SiteKit is a tiny Perl helper that centralizes the canonical web links and basic site metadata for the FacialHarmonyAI service. It supplies simple functions such as analysis_url to get the standard upload endpoint, report_url($id) to build a shareable report link, and site_metadata to fetch site info, making it easy to produce consistent URLs for redirects, emails, API responses, or UI links in applications that integrate with FacialHarmonyAI. The module is lightweight, straightforward to include in your code, and is available under the MIT license. Website: https://facialharmonyai.com

Crypt::Passphrase is a lightweight, flexible toolkit for handling password hashing and verification in a way that makes upgrading algorithms and parameters easy. You configure a single encoder used for new passwords and an optional list of validators for accepting older hash formats, then use simple methods to hash passwords, verify credentials, and detect when a stored hash should be rehashed with a stronger scheme or different settings. The module understands Unicode normalization, supports peppering strategies and hardware security modules through available backends, and can recode hashes when encodings change. It does not implement hash algorithms itself so you pick the appropriate backend modules such as Argon2, Bcrypt, Yescrypt, PBKDF2 or system crypt implementations depending on your needs. The author recommends tuning parameters for your deployment, guarding against DOS risks from expensive hashing, and treating normalization consistently across your database. If you need a practical way to migrate legacy password stores and keep password handling up to date, Crypt::Passphrase is a good fit and integrates with common frameworks and ORMs.

MARC::Record is a Perl module that represents MARC bibliographic records as objects and makes it easy to read, build and manipulate their fields without dealing directly with low-level file parsing which is handled by MARC::File::* drivers. It provides simple constructors including a USMARC wrapper, convenience accessors for common elements like title, author, edition and publication date, and field-level operations to append, insert (including grouped and ordered insertion), delete and clone fields or subrecords. The module exposes encoding control for MARC-8 versus UTF-8, collects errors in $MARC::Record::ERROR and stores per-record warnings accessible via warnings(), and is aimed at quick prototyping and extensibility rather than raw performance. Recent maintenance in the 2.0.7 release fixes packaging details and restores marcdump so it prints warnings when dumping records.

Sidef is a modern, multi-paradigm programming language exposed as a Perl module so you can parse, compile and run Sidef code from Perl programs or embed Sidef as a configuration or expression language. It blends object-oriented and functional styles with features like multiple dispatch, pattern matching, first-class functions, lazy sequences and native arbitrary-precision integers, rationals, floats and complex numbers, while offering built‑in regexes, Unicode handling and optional type checks. Sidef integrates directly with the Perl ecosystem so you can require CPAN modules without wrappers, and it can decompile to Sidef or compile to Perl for inspection or maximum runtime speed. The module supports AST parsing and optimization, multi-level compilation optimization (O=0,1,2), and an optional DBM-backed compilation cache with compression to accelerate repeated execution. You get a CLI and REPL for interactive use, utilities for config and versioned cache directories, and helper methods for compiling, executing and debugging Sidef code from Perl; note that building Sidef requires native math libraries (GMP, MPFR, MPC) and that DB_File or GDBM_File is needed to enable caching.

JSON::Any is a compatibility wrapper that gives you a single, stable API for working with JSON in Perl and automatically picks one of the available JSON backends (Cpanel::JSON::XS, JSON::XS, JSON::PP, JSON, or JSON::DWIW) so your code can call objToJson/jsonToObj or encode/decode/to_json/from_json and work regardless of which implementation is installed. You can control backend preference on the use line or via the JSON_ANY_ORDER environment variable and you can access the underlying handler and its true/false values when needed. The module recognizes common options such as utf8 and allow_blessed and will even attempt to ensure a fallback JSON::PP is available at install time. JSON::Any is now deprecated in favor of JSON::MaybeXS for new projects but is still maintained for compatibility and special cases, and you should be aware of documented issues such as a potential conflict between newer JSON::XS and very old JSON.pm versions. Recent updates improved compatibility with modern JSON::XS and Cpanel::JSON::XS releases and fixed a test issue with Cpanel::JSON::XS >= 4.42.

JMAP::Tester is a lightweight test client for exercising and validating JMAP servers, useful if you are building or testing a JMAP implementation or debugging server behavior. The module wraps JMAP method calls and HTTP responses into easy-to-inspect objects called Sentences and Paragraphs so you can assert things like the number of returned items or the presence of specific method responses. It supports uploads and downloads, session discovery and configuration, custom HTTP requests, and configurable JSON handling with JSON::Typist-aware encoding and convenient helpers to strip typist types, and it can optionally return Future objects for asynchronous test flows. You can set defaults such as accountId and capabilities, enable pretty JSON output, and tweak request generation via hooks, making it handy for scripted integration tests. Note that the library is early stage so expect the API to evolve.

SPVM is a compact statically typed language with Perl-like syntax designed for high performance and native interoperability. It gives you familiar Perl-style code but with static types, ahead-of-time and just-in-time compilation, native C and C++ bindings, a resource system for shipping native code, and the ability to call SPVM methods directly from Perl or produce standalone executables via spvmcc. The standard library mirrors many Perl conveniences while adding modern features such as threads and goroutine-like execution, type inference, static analysis and easy linking to existing C/C++ libraries. If you want a Perl-flavored language that compiles to fast native code or to mix high-level SPVM code with low-level native extensions, SPVM is relevant; note it is pre-1.0 and the project does not guarantee backward compatibility across releases. Recent work has focused on build and tooling improvements including better Windows/MSVC support and ensuring SPVM is listed in CONFIGURE_REQUIRES for Makefile.PL files produced by spvmdist to make module builds more reliable.

Zuzu is a small Perl helper module that makes it easy to parse and run ZuzuScript code from Perl. It exposes simple functions to evaluate a ZuzuScript source string or a UTF‑8 script file and returns the evaluation result while accepting runtime options such as denying modules or adding library search paths to control execution. Use it to embed ZuzuScript in Perl tools, run quick one‑off scripts, or drive tests without wiring up a full runtime. For language details see zuzulang.org. Released under the Artistic License 1.0 or GPL version 2.

YAML::PP is a modular, pure-Perl YAML processor that aims to implement the YAML 1.2 Core and YAML 1.1 schemas accurately and to give you fine grained control over loading and dumping YAML documents. It provides familiar entry points like load_string, load_file, dump_string and dump_file plus drop in functions Load, LoadFile, Dump and DumpFile, supports multi-document streams, pluggable schemas for JSON, Failsafe, Perl objects, merges and includes, and can preserve ordering, scalar styles and flow styles when requested. The module exposes many options to control boolean handling, maximum nesting depth, header/footer and version directives, and it can be extended with alternate parsers such as a libyaml backend for speed. The author notes that some inner APIs and preservation features are experimental and that a few rare YAML syntax cases remain unsupported, and users should expect YAML::PP to be slower than XS-based alternatives while offering stronger spec compliance and predictable type resolution across languages. If you need a Perl YAML tool that focuses on correctness, schema flexibility and preserve-friendly roundtrips, YAML::PP is a solid choice.

POSIX::RT::Timer provides Perl bindings for POSIX real‑time timers so you can create and manage many independent timers that deliver a signal when they expire and can run on a variety of clocks such as realtime, monotonic, boottime and CPU clocks. You create timers with new and control them with methods to set or get relative or absolute timeouts and intervals, inspect how many expirations were missed with get_overrun, and obtain the raw timer handle when needed. The module is useful when you need finer control and more timers than getitimer/setitimer offer, and it now uses Time::Spec for all time values for cleaner time handling. Be aware that Perl’s default signal delivery drops extra information like the timer id, so getting that data requires unsafe handlers or a synchronous signal receiver such as POSIX::RT::Signal or Linux::FD::Signal, which carry their own tradeoffs.

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.