CPANscan

Mojolicious::Plugin::BarefootJS integrates the BarefootJS server runtime into a Mojolicious application by registering a "bf" controller helper that provides a per-request BarefootJS instance backed by BarefootJS::Backend::Mojo. It lets you render compiled BarefootJS marked templates as normal Mojolicious templates and installs the supporting hooks so rendering happens smoothly within each request. If you prefer a framework-free setup, the same runtime can be driven with BarefootJS::Backend::Xslate and Text::Xslate. The plugin is lightweight, focused on wiring the runtime into Mojolicious, and is available under the MIT license.

BarefootJS::Backend::Xslate provides a simple bridge that lets the BarefootJS runtime render Kolon-style Text::Xslate templates. It can take an existing Text::Xslate object or build one from a list of template paths, binds the runtime into templates as the bf variable so helpers are invoked naturally, and configures Xslate for HTML auto-escaping while offering a mark_raw mechanism for helper-produced markup. You can override the JSON encoder if needed and call render_named to render a named .tx template with variables. Because it has no web-framework dependency it runs under PSGI/Plack or in standalone scripts and pairs cleanly with the @barefootjs/xslate compile-time adapter that emits templates expecting the bf runtime.

BarefootJS is a lightweight server runtime for rendering BarefootJS templates that were compiled from JSX/TSX into marked templates and accompanying client JavaScript. It intentionally stays framework and engine agnostic and delegates framework-specific tasks like JSON marshalling, raw-string marking, children handling, and named-template rendering to pluggable backends so the same runtime can drive different Perl rendering stacks. Out of the box it has backends for Text::Xslate and Mojolicious and it only pulls in noncore template or web framework code when a backend requires it, keeping the core minimal and easy to embed in PSGI/Plack or Mojolicious applications. If you need to render BarefootJS templates from Perl across multiple frameworks or want a backend-driven, low-dependency approach, this module provides that and is actively maintained with releases through 2026.

WWW::Gitea is a lightweight Perl client for the Gitea REST API that makes it easy to script and automate common operations on a self hosted Gitea instance. Built with Moo, it exposes resource controllers for repositories, issues, pull requests, labels, milestones, releases, organizations and users so you can do things like create a repo, open or comment on an issue, create and merge a pull request, or publish a release with simple method calls. Authentication works with a personal access token or basic auth and the client will derive the API base URL from the instance root you provide or from environment variables like GITEA_URL and GITEA_TOKEN. Calls return small entity objects wrapping the decoded JSON while keeping the raw data available, and internal operation tables are precomputed so there is no OpenAPI parsing at runtime. If you need a straightforward programmatic interface to manage Gitea resources from Perl, WWW::Gitea provides an intuitive, minimal layer over the API.

Dist::Zilla::PluginBundle::Author::GETTY is a ready-made Dist::Zilla configuration that encodes the packaging, metadata, versioning and release practices used by the CPAN author GETTY, so you can build and release Perl distributions with a consistent, automated workflow. It wires together common plugins to generate META and POD, manage versions and changelogs, run pre and post build or release commands, and integrate with GitHub or self-hosted Gitea for repository metadata and release creation. The bundle also supports XS and Alien-based C libraries, optional Docker image builds, control over what files are shipped, and flags to skip CPAN uploads or other steps, while exposing many attributes for fine-grained customization. A companion GitHub Action and CI guidance make it easy to reproduce the same authoring and test environment across projects, which makes this bundle a good fit for Perl authors who want a well-tested, configurable release pipeline without hand-crafting every Dist::Zilla plugin.

Crypt::OpenSSL::PKCS12 is a Perl wrapper around OpenSSL's PKCS12 API that makes it straightforward to read, create and manipulate PKCS#12 files used to bundle private keys, X.509 certificates and CA chains. You can load a .p12/.pfx from a file or string, extract certificate, CA chain and private key as base64 or raw output, verify the MAC, change passwords, and create PKCS12 output either to disk or as a string. It can also reproduce OpenSSL's pkcs12 -info output and deliver a parsed representation as a Perl hash for scripts that need to inspect a file's internal structure. The module supports OpenSSL 1.x and 3.x and requires a standard OpenSSL installation and Perl 5.8 or newer, so it is a handy choice when you need to automate certificate packaging or integrate PKCS#12 handling into Perl tools.

MCP is a Perl SDK that implements the Model Context Protocol so you can expose Perl tools, prompts and resources to AI systems with minimal fuss. It lets you register named tools with descriptions, JSON Schema-validated inputs and handler code, then serve them over HTTP in a Mojolicious app or run a local stdio transport for testing and command-line use. The module supports structured, image, audio and resource results, sessions, notifications and optional streaming, and it integrates authentication hooks so your application can enforce access controls. Recent updates add OAuth 2.0 scope support so MCP servers can act as resource servers and provide finer-grained scope checks; note that server-to-client streaming is opt-in and not compatible with prefork web servers. If you want a Perl-native way to connect text-processing code to modern AI workflows with schema validation, session management and optional streaming, MCP is a good fit.

Win32API::File::Time is a small Perl module that gives you direct control over file timestamps on Windows, letting you read and set a file's creation, modification, and access times. It exposes GetFileTime and SetFileTime and can override Perl's built-in utime so you can update timestamps even on open files, read-only files, and directories by calling the Windows SetFileTime API. You can update only the fields you care about by passing undef or 0 for times you want to leave alone, and the calls return standard success or failure values with errors available in $^E. Be aware that calling GetFileTime itself counts as an access and may change access time, FAT filesystems have coarse time resolution, and some wide-system-call code paths and Windows testing are limited by the author's environment. The author maintains the module and accepts bug reports and offers for co-maintainership via the project GitHub.

Astro::Coord::ECI::TLE::Iridium is a Perl subclass of Astro::Coord::ECI::TLE that models the original-design Iridium satellites and predicts their reflective "flares" for a ground observer. It parses TLE data and reblesses known Iridium vehicles, computes when and where specular or non-specular reflections occur, estimates apparent magnitude with optional atmospheric extinction, and returns detailed flare records including time, azimuth, elevation, magnitude, antenna, virtual image and status. You can control which flare types to report and use satellite status data from SpaceTrack or canned tables. The author warns this is specific to the legacy Iridium hardware and will not work for Iridium Next, it has geographic and platform limits (not beyond about 85 degrees latitude or for non‑fixed stations), and flare functionality is now largely historical because the flaring fleet has been retired. Recent updates were packaging and metadata fixes only and made no functional changes.

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.