CPANscan

JSON::JSONFold reformats pretty-printed JSON into a more compact, readable layout that reduces unnecessary vertical space in arrays, objects and simple nested structures. It can be used as a simple functional API, an object-oriented formatter, a streaming post-processor that writes folded output without buffering the entire document, or as a drop-in replacement for JSON::encode_json and JSON::to_json. Configuration options let you control target line width, indentation, key sorting and preset compacting behavior, and the module can write results to filehandles and return formatting statistics. Use JSON::JSONFold when you want human-friendly JSON that is denser and easier to scan than conventional pretty printing.

pEFL is a Perl binding for the Enlightenment Foundation Libraries that lets you build EFL-based graphical and event-driven applications from Perl using an object oriented API that stays close to the original C calls. It exposes Elementary, Evas and Ecore functionality so you can create windows, widgets, callbacks and events, and it provides Perl-friendly variants of functions (suffix _pv) that return Perl arrays or bless returned objects into the appropriate classes. Helpers such as ev_info2obj and ev_info2s convert C event info into usable Perl values and output parameters from C methods are returned as multiple Perl return values to keep the interface natural for Perl programmers. The binding is described as stable and well tested and aims to follow the C documentation closely, though some advanced features like creating SmartClasses in pure Perl are not yet available. Documentation and examples are available with the distribution and the source and issue tracker are on GitHub.

App::BPOMUtils::RPO::Ingredients provides a command line utility and an exportable function to turn a CSV of product ingredients into a label-ready, grouped ingredient list for Indonesian processed food registration. You give it a simple CSV on stdin and it merges ingredient groups, inner ingredients, QUID values and notes into human readable entries in either Indonesian or English, with an option to control QUID precision. The tool emits a compact Ingredient,%weight CSV suitable for product labels and returns an enveloped result array with HTTP-like status codes and metadata so it can be integrated into scripts and pipelines. It is useful for food manufacturers, label preparers and regulators working with BPOM RPO ingredient declarations.

App::sdif bundles a small suite of command line tools that make diffs easier to read and monitor, most notably sdif for side-by-side diff output, cdif for visually highlighting changed words or characters, and watchdiff for repeatedly running a command and emphasizing what changed between runs. It is aimed at anyone who reviews code or tracks changing text on the terminal and can be plugged into git as a pager so diffs and logs render with nicer, in-context highlighting. The tools support extra tokenization via mecab for better word boundaries in languages like Japanese and are distributed on CPAN for easy installation with cpanm.

RPi::Const is a small utility module that collects and exports the named constants used by the RPi::WiringPi family so you can write clearer Raspberry Pi GPIO code without scattering magic numbers. You can import everything or pick tagged groups such as pin-numbering modes, pin direction and pull-up settings, pin states, PWM mode and defaults, interrupt edge types, and MCP23017 expander registers and pin names. The module only supplies constant values and does not perform any hardware access or control. Note that the suite intentionally does not provide a physical-pin setup constant.

Net::Whois::IP is a Perl helper for looking up WHOIS information about IP addresses by recursively querying registries until it finds detailed contact data such as technical phone numbers. In scalar context it returns a parsed hash of fields for the best result and in list context it can return the full chain of responses from each lookup. You can request raw unparsed responses or enable a mode that preserves all duplicate field values as arrays, and there is an advanced option to override which fields are used in searches though that can break lookups if used incorrectly. For ARIN queries the module may prepend synthesized parent records derived from ARIN summary output and tag them as ARIN-SUMMARY, and those synthesized entries may contain fewer fields than full WHOIS records. This module is suitable for network operators and developers who need programmatic access to IP ownership, contact and allocation details.

WWW::Mechanize is a Perl module that gives you a programmable, stateful web browser for automating interactions with websites. It builds on LWP::UserAgent and adds high level support for finding and following links, filling and submitting HTML forms, automatic cookie handling, SSL, custom headers, redirects, proxies and HTTP authentication, plus a navigable history of visited pages. That makes it a handy tool for web testing, screen scraping and small web robots because you can script sequences of GETs and POSTs, select forms by name or fields and extract page content, links and images without parsing raw HTML yourself. It is not a full browser replacement so it does not execute JavaScript and you will need additional tools if you must interact with JS-driven pages.

JMAP::Tester::WebSocket is a small testing client that wraps JMAP::Tester to talk to JMAP servers over WebSocket. You create it with a ws_api_uri and use its request method to send JMAP method calls and receive parsed responses, making it easy to write automated tests against a server's JMAP implementation. It supports optional logging of requests and responses via the JMAP_TESTER_LOGGER environment variable and includes a configurable timeout (30 seconds by default) to avoid hanging tests. The current release requires JMAP::Tester 0.110 so it can take advantage of improved diagnostic dumping and an abort method on result objects, which helps surface richer debugging information during test runs.

Math::Rand48::Cursor lets you recover and navigate the internal state of Perl's built-in rand function, which uses the drand48 48-bit linear congruential generator. From a single observed rand() output you can reconstruct the exact 48-bit generator state, reproduce that output, step forward or backward one step at a time, or jump an arbitrary number of steps ahead or back. You can also construct a cursor from an explicit 48-bit state or from a seed as handled by srand, with the module following Perl's seed coercion rules such as truncating fractional seeds, treating negative seeds by absolute value, using only the low 32 bits, and rejecting NaN or Inf. The cursor exposes the state as a Math::BigInt and returns the float that rand() would produce for the current state, making this useful for debugging, testing, reproducing sequences, or exploring the behavior of Perl's RNG. Initial release 0.001.

Travel::Status::DE::DBRIS is an unofficial Perl client for Deutsche Bahn's bahn.de departure monitor and train information APIs that makes it easy to fetch station departure boards, search stations by name or geolocation, and retrieve journey details and carriage formation data. It supports both blocking and promise-based nonblocking use with familiar Perl objects for locations and trips, offers options to cache responses or failed requests to reduce load, and lets you filter transport modes or request intermediate stops. Developer mode prints raw requests and responses for debugging. Recent releases improve carriage‑formation parsing and add workarounds for delays and blocking caused by Akamai's WAF, including randomized headers and support for Brotli responses, so the module is actively maintained but still unofficial and best used with caching and reasonable request rates to avoid triggering rate limits.

Schema::Test is a lightweight helper for working with versioned DBIx::Class schemas that makes it easy to select and inspect specific schema releases for testing and migration checks. You create an instance with an optional version parameter and then call simple methods to list available versions, retrieve the selected version string, or get the DBIx::Class schema class name associated with that version. It is a thin wrapper over Schema::Abstract and uses shared version metadata, so it is most useful when you need to drive tests or tools against multiple historical schema layouts. The 0.02 release adds a 0.3.0 test schema that includes a new address table and brings documentation and tests in line with the module.

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

Perl::Critic::Policy::ControlStructures::ProhibitBareBlockLoopControls is a lint rule for Perl that finds uses of loop-control words next, last, and redo where they are confusing or dangerous, for example inside bare { } blocks, do { }, anonymous subs, eval, or map and grep blocks. It helps prevent subtle bugs caused by bare blocks behaving as one-pass loops, by loop controls escaping to an outer loop, or by runtime errors when no real loop exists. The default behavior forbids next and redo in non-loop blocks and requires an explicit label for last, and you can tune each keyword and narrow behavior for bare or do blocks in your perlcriticrc. Use this policy when you want clearer, safer control flow and to avoid surprising semantics during refactoring or code review.

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.