CPANscan

Treex::PML is a Perl library that implements the Prague Markup Language (PML) to read, write and manipulate linguistically annotated treebanks and related XML-based annotation formats. It provides a high-level object model for documents, trees and nodes, schema-aware instances and utility types, pluggable I/O backends and optional on-the-fly XSLT conversion so you can load, validate, convert and traverse complex annotation layers without dealing with raw XML. The package uses a Factory pattern so you can swap in customized class families, includes helpers for resource-path resolution and deep cloning, and still supports older FS-format treebanks used by the TrEd ecosystem. If you work with dependency or constituency treebanks, corpus conversions or tooling around PML, this module gives you a ready-made, extensible Perl API; recent updates fixed saving of relative resource paths and made the test suite compatible with Perl 5.10.

Finance::Tax::Aruba is a Perl toolkit for calculating Aruba-specific taxes, focused mainly on individual income tax and payroll-related components at a practical, user level. It handles yearly tax rules across recent years and includes support for pensions, employer- and employee-paid premiums, fringe and non-fringe benefits, child deductions, and computations of employer social and government costs, with a bundled payroll helper script (bin/loon.pl) to simplify typical use cases. The distribution is actively maintained and recent releases added 2025 support and fixed a bug in the lowest income tier for 2023/2024. The author lists further planned improvements such as elderly deductions, dual-household calculations, SVB fees and other tax types, so the module is a good fit if you need a straightforward Perl-based way to model Aruban individual payroll and income tax today and want a project that is continuing to gain features.

Protocol::Gearman is an abstract base class that provides the common plumbing for implementing Gearman clients and workers rather than a drop-in tool for end users. It defines the minimal methods an implementation must supply, such as a send method to transmit bytes, new_future to create Future objects for asynchronous responses, and a place to stash Gearman-related state, and it supplies a suite of helpers for packing, parsing and sending Gearman protocol packets, dispatching received messages and handling simple request patterns like echo. The module also offers a convenient new_prototype constructor so you can build lightweight prototypical client or worker objects with code references, which is handy for tests and small scripts. Recent updates refreshed the codebase for newer Perl features and fixed a Future API compatibility issue, so the module is current and suitable as the foundation for custom Gearman implementations.

Apertur::SDK is the official Perl client for the Apertur API that makes it simple to manage upload sessions, send images, verify webhooks, and perform full CRUD on resources like destinations, API keys, webhooks, and encryption keys. You create a client with an API key or OAuth token and the module auto-detects sandbox versus live environments from the key prefix, then exposes focused resource accessors for uploads, polling, stats, and more so you can integrate Apertur workflows with a few straightforward calls. It supports plain and encrypted image uploads, long polling to retrieve processed assets, and helpers to verify webhook signatures, with encryption features enabled on demand via optional Crypt::OpenSSL::RSA and CryptX dependencies. Errors from the API are raised as typed Apertur::SDK::Error objects so you can catch authentication, rate limit, validation, and not found conditions explicitly. The SDK relies on common Perl HTTP and JSON libraries and is released under the MIT License.

Test::Which is a small testing helper that makes it easy to skip unit tests when required external programs are not available or do not meet version requirements. You can declare program requirements at compile time or check them at runtime with which_ok, and the module will locate executables on PATH or accept absolute paths, probe their version output using a built in heuristic or a custom flag or extractor, and compare versions with standard operators or regexes. Results are cached for the life of the process to avoid repeated invocations and verbose output can be enabled via environment variables so your test runs show the detected versions. The module works across Unix, macOS and Windows though platform quirks are noted and unusually formatted version output may need a custom extractor or explicit version_flag. Recent updates added a configurable timeout for program probes, better Windows handling and fixes to ensure messages are not lost.

Data::MARC::Leader is a compact Perl object for representing and validating the 24-character leader of a MARC bibliographic record. It provides a constructor and simple accessors for each leader element such as record length, record type, record status, character coding scheme, base address of data and the various length and count fields. The module enforces allowed codes and field lengths and can hold the raw leader string, so it is useful for building, parsing or checking MARC records in library systems, conversion scripts and data validation workflows. It is lightweight and designed to plug into Perl toolchains that work with MARC data.

MARC::Leader::Print is a lightweight Perl formatter that turns a Data::MARC::Leader object into easy-to-read text for display or logging, making the 24-byte MARC leader understandable at a glance. By default it prints descriptive labels for each leader element but it can be switched to show raw values instead, and it can return either a single joined string or an array of lines. You can enable optional ANSI color output and control it via a constructor flag or environment variables, and you can customize the scalar output separator. It is aimed at developers and cataloging staff who need a simple way to inspect or present MARC leader data and integrates with Data::MARC::Leader and common Perl utility modules; source and license information are available on the project GitHub.

Crypt::SMIME is a Perl class for creating and handling S/MIME email messages that lets you sign, verify, encrypt and decrypt MIME content using OpenSSL's libcrypto. It works with PEM and PKCS#12 keys and certificates supplied as strings rather than filenames and exposes simple methods to set private and public keys, produce detached signatures, verify signed messages, encrypt for one or more recipients, and decrypt incoming S/MIME. The module also provides helpers to extract certificates, enumerate signers and read a peer's SMIMECapabilities, supports taint awareness and lets you control verification time and flags including CRL checks. Recent updates require OpenSSL 3.0 or newer, add an optional cipher argument so you can use modern AEAD ciphers like AES-GCM while preserving a sensible AES-128-CBC default, and ensure the module advertises AEAD support in signatures for better interoperability. If you need straightforward S/MIME support from Perl and already have OpenSSL available, Crypt::SMIME is a practical, maintained choice.

MOP4Import::Declare is a toolkit for building custom Perl exporters that turns use/import arguments into structured "declare_*" method calls so you can add pragmas, symbols, methods and variables to a target package in a consistent way. It dispatches incoming import items by type so a bare "-name" triggers declare_name, an arrayref like [name => @args] invokes declare_name with arguments, ordinary names and sigils are handled like traditional exports, and code refs can act as callbacks. A small Opts object carries caller information into each handler and the module provides helpers for common needs such as defining fields, constants, adding base or parent classes, remapping methods, and marking modules in %INC. It also offers convenience pragmas like -strict and -as_base and emits debug traces when DEBUG_MOP4IMPORT is set. If you need features beyond its built in dispatching, you can subclass and override dispatch_import to implement tag lists or other advanced Exporter behavior.

Dist::Zilla::Plugin::Repository automatically detects your project’s version-control checkout and writes the repository information into the distribution metadata so CPAN and other tools can link back to your source. You enable it by adding [Repository] to dist.ini and it handles common systems such as git, svn, cvs, darcs, bzr and hg while letting you override detection with an explicit repository URL or choose which git remote to use. It maps repository and web URLs into CPAN Meta fields and supports modern metadata practices, though the old github_http option is deprecated and using the MetaJSON plugin is recommended if you need both clone and web URLs. The most recent release broadened support for marking repositories with issue and web endpoints so hosting platforms like GitHub, GitLab and Bitbucket are represented correctly. The implementation is largely based on Module::Install::Repository, so it should feel familiar to users of that tool.

Math::GMPf is a Perl binding to the GNU MP (GMP) library's mpf floating‑point facility that gives you arbitrary precision "bigfloat" arithmetic from Perl. It wraps GMP's mpf API as Perl functions and methods for creating and assigning high‑precision floats, controlling precision, performing arithmetic and comparisons, converting to strings and native numeric types, formatted I/O, and generating random floats, and it overloads common numeric operators so Math::GMPf objects behave like native numbers. The module requires the GMP C library to be installed and returns blessed objects that are automatically cleaned up when they go out of scope, with alternative nobless functions if you want manual memory control. Use Math::GMPf when you need accurate floating point calculations beyond built-in doubles or when you want direct access to GMP functionality from Perl. Note that incorrect argument types can cause interpreter crashes, so follow the documented argument conventions and consult the GMP manual and the module test suite for examples.

Apache2::API is a developer-friendly Perl framework that sits on top of Apache/mod_perl2 and makes the server API much easier to use. It wraps request, response and server objects and provides ready-made helpers for JSON encoding and decoding, URL and UTF-8 handling, base64, UUID generation, htpasswd-style password hashing, logging and localized messages, plus convenient reply and bailout methods that format HTTP and JSON responses and errors for you. The module also manages handler registration, supports Server-Sent Events replies and optional response compression based on client capabilities and a configurable threshold. It exports Apache and APR constants for convenience and is designed to be extended, for example to provide custom gettext localization. If you are building mod_perl handlers or embedding Perl in Apache this module will save a lot of boilerplate and make common tasks straightforward, but it is only relevant in an Apache/mod_perl environment.

Git::Server is a drop-in replacement for a standard Git server that adds far more flexible server-side hooks, fine-grained access control and deployment tooling so you can enforce who can push what and trigger automated actions on every push or pull. It installs alongside SSH using an authorized_keys command and provides features like ACLs for writers, forcers and file-level push restrictions, IP and author-email whitelists, customizable pre/post hooks, webhook notifications, a git-client wrapper and a git-deploy helper for instant or background deployments. The module also supports proxy syncing to external remotes, detailed logging and safer defaults for bare repositories, and it includes helpers to verify SSH keys and client behavior. Recent releases improved the proxy functionality to allow multiple remote targets and syncing to empty repos, beefed up git-verify and git-deploy key handling and options, tightened a few security behaviors and added nicer diagnostics such as showing which public key connected; the project is actively maintained on GitHub with ongoing enhancements and bug fixes.

Perl::Critic::Policy::Security::RandBytesFromHash is a Perl::Critic policy that scans your code for the old and unsafe habit of generating "random" bytes by hashing predictable values such as rand, time, process id, reference addresses or internal counters and warns when it finds patterns like md5(rand() . time() . $$). It helps developers catch this subtle security footgun and points them toward proper sources of randomness such as Crypt::URandom, Crypt::SysRandom or Crypt::PRNG. You enable it in your perlcriticrc and adjust severity as needed. Be aware it will conservatively flag any hash or join that includes insecure inputs and can sometimes report the same construct more than once. This module requires Perl 5.24 or newer.

MARC::Leader::L10N is a lightweight localization helper for projects that work with MARC leader labels and need translated text. You request a language handle with get_handle using an ISO 639-1 code or let it pick the locale default and then call maketext with a key to get the localized string. If a requested language is not available get_handle returns undef. The module builds on Locale::Maketext and is intended for library or metadata tools that want simple, consistent translations of leader-related labels. It is BSD 2-Clause licensed, available on GitHub, and this 0.01 release is the initial public version.

RT::Client::REST is a Perl library that lets your application talk to a Request Tracker (RT) server using its REST API, effectively converting the old command-line "rt" tool into an object you can script against. You can authenticate, fetch, create and edit objects like tickets, users and queues, post comments and correspondence, attach files, search and sort results, inspect transactions and links, merge or link tickets, and take or steal ownership, all while errors are delivered as catchable exceptions so you can handle them with Try::Tiny or eval. The API mirrors the original rt tool so simple tasks are quick to script and there are also more object-oriented companion classes such as RT::Client::REST::Ticket and RT::Client::REST::User for nicer OO usage. Note that show() and edit() operate on a single object at a time and the module currently does not retrieve RT forms, and recent maintenance releases such as 0.73 focus on bug fixes including correcting a get_links URL bug and other small namespace and typo fixes. If you need to automate or integrate RT operations from Perl programs this module is a practical, well maintained choice.

Control::CLI::Extreme is a Perl module for automating command-line interaction with a wide range of Extreme Networks (and ex‑Avaya/ex‑Nortel) devices over Telnet, SSH or serial consoles, providing a consistent scripting interface that handles varied prompts, login sequences, paging and confirmation prompts so you can run show and configuration commands reliably across different models. It subclasses Control::CLI and adds device-aware conveniences such as automatic device discovery and prompt setting, optional return-of-result mode for config commands, efficient return-of-output for show commands, non‑blocking polling to drive many devices in parallel without threads, and helpers for console wake sequences and serial baud changes. The module supports many families including ExtremeXOS, PassportERS, BaystackERS, SLX, ISW, VSP, WLAN and others, exposes device attributes like model, sysname and ports for conditional scripting, and works with SSH password or publickey authentication. Recent updates add OneOS support and a serial_number attribute, fix documentation and Perl warning issues, and otherwise refine prompt and error detection across newer hardware and firmware. If you need to automate CLI workflows across mixed Extreme gear and prefer a single, device-aware API for Telnet, SSH and serial access, this module is directly relevant.

Control::CLI is a pure-Perl toolkit that gives you a single, consistent API to drive command‑line interfaces over Telnet, SSH or serial ports and to capture their output. It wraps Net::Telnet, Net::SSH2 and Device::SerialPort or Win32::SerialPort so you can connect, authenticate, send commands, wait for prompts and log or hex-dump traffic without changing your code for each transport. The module supports terminal type and window size negotiation, SSH publickey and password authentication, IPv6 when IO::Socket::IP is available, and serial‑port features like baud, parity and on‑the‑fly baud changes. It includes a non‑blocking poll framework to manage many hosts from a single thread and helpers for parallel connect/login/cmd workflows, while also offering fine control of timeouts, prompt matching, newline translation and logging. Note that some transports require their underlying CPAN modules to be installed and that Net::SSH2 only implements SSHv2 and has portions of the auth flow that are not fully non‑blocking, which can affect very large parallel SSH batches. Overall this module is ideal for network engineers and sysadmins who need portable, scriptable automation of routers, switches and appliances across Telnet, SSH and serial links.

OpenGL::Modern is a comprehensive Perl binding to the OpenGL API (covering legacy 1.x up through modern 4.6) built on top of GLEW and generated from glew.h and the Khronos registry so the interface stays aligned with upstream changes. It exposes the full set of core and extension functions with granular export tags, POGL-like convenience variants for pointer and array arguments, and development helpers such as glpSetAutoCheckErrors to automatically call glGetError during debugging. The module includes compatibility shims so OpenGL::Image can work without loading the legacy OpenGL.pm and supports both Config and ExtUtils::Depends style builds. Recent releases fixed a long-standing crash by making glewInit verify there is an active GL context and return an error instead of segfaulting when none exists and added a glewHasContext() XS function to check context state. If you want direct, up-to-date OpenGL and extension access from Perl for graphics or GPGPU work this module provides a production-ready, well maintained solution.

Meetup::API is a lightweight Perl wrapper for the Meetup.com REST API that makes it easy to fetch groups, events and related data from Perl code using simple method calls like group_events->get. It defaults to API version v3 but lets you override the version when constructing the object. To use it you register with Meetup, obtain an API key and place a JSON file named meetup.credentials in your home directory with an applicationKey field so the module can authenticate. The distribution depends on common JSON modules (JSON::PP/JSON::XS) and is maintained on GitHub; a recent release fixed compatibility with Net::CalDAVTalk 0.14 to avoid breakage.

DBIx::SearchBuilder is a mature, DBI-backed Perl toolkit that makes it easy to express SQL queries and row handling in object form so you can build, page, sort, join and count result sets without hand-crafting raw SQL for every operation. You use it by subclassing SearchBuilder for a collection and providing a Record subclass for rows, then apply Limit, OrderBy, GroupBy, Join and paging methods to describe what you want and iterate over results with Next or grab them as an array. The module can emit the actual SELECT it builds for debugging, supports bind variables and query hints, handles distincts and complex joins, works with common DBD drivers including SQLite, Postgres, MySQL/MariaDB and Oracle, and is designed to be extended by application code. One noteworthy recent change is that the lazy-load column behaviour is now disabled by default so column fetching is simpler out of the box, though the configurable options for selective loading remain for advanced use.

Class::Mite is a minimal, high-performance object and role framework for Perl that bundles a tiny Role composer and a lightweight Class base. The Role component provides method composition with requires, excludes and with keywords and detects conflicts between roles. The Class component supplies a simple hash-based new constructor that automatically calls an optional BUILD hook and makes it easy to consume roles. The distribution also includes small helpers such as Class::More and Class::Clone and aims to give Moo and Role::Tiny style ergonomics with near-zero dependencies for developers who want a compact, fast way to build classes and role-driven behavior.

Aion is a modern, compact object system for Perl 5 that makes it easy to declare classes and roles with concise "has" properties and rich attribute options. It supports read/write/ro/wo permissions, required and constructor-less attributes, lazy defaults and builders, coercions, triggers, cleaners, custom accessors, predicates and clearers, plus role composition with with, requires and req. Aion includes a flexible type system and method signature checking via the :Isa attribute, and it adds extensible aspects so roles can introduce new attribute behaviors. It also provides dependency injection via the eon aspect working with the Aion::Pleroma container for autowiring services. If you know Moose, Moo or Mouse you will find Aion familiar but leaner and focused on extensible aspects and DI. The recent release improved pleroma autoinitialization by replacing the package variable with an Aion->pleroma accessor.

Kubernetes::REST is a lightweight Perl client that lets you talk to the Kubernetes API with a clean, high-level interface and typed IO::K8s resource objects instead of raw hashrefs. It covers common operations such as list, get, create, update, patch and delete, and it also supports streaming watches and pod logs plus pod port-forward, exec and attach when your HTTP backend can provide duplex transport. The transport is pluggable so you can use the default LWP backend, the lighter HTTP::Tiny backend, or plug in an async engine, and the client can dynamically load the cluster resource map to match your Kubernetes version. If you need idempotent deployments or automation, recent releases added ensure, ensure_all and ensure_only for create‑or‑update workflows that handle race conditions and server-side immutability for resources like PersistentVolumeClaim and Job while accepting either IO::K8s objects or plain manifest hashrefs.

Log::Fmt::XS is a drop-in subclass of Log::Fmt that swaps performance-critical parts into XS (C) code so emitting logfmt key=value log lines is noticeably faster. If you use Log::Fmt for structured, machine-friendly logging this module gives you the same behavior and API while reducing CPU overhead and improving throughput under load. It is intended as a transparent speed-up rather than a functional rewrite, so you can usually adopt it without changing your logging code. Be aware the author does not promise stable Perl version requirements forever, so future releases may require a newer Perl.

App::MARC::Leader is a lightweight base class for the marc-leader command line tool that decodes the 24-character MARC record leader and presents a human-friendly interpretation of its fields. It can read leaders from MARC XML or accept leader strings and relies on MARC::File::XML and MARC::Leader to do the parsing. The output shows labeled values such as record length, record status, type of record, bibliographic level, character coding scheme, indicator and subfield counts, base address of data and encoding level and it supports optional ANSI colored output for easier reading. The module exposes a simple new/run application API for embedding in scripts or building a CLI. Recent updates added a verbose mode (-v), made a leader string optional, and improved help text and documentation. This is a handy tool for librarians, metadata engineers and developers who need a quick, readable way to inspect or debug MARC leaders.

Convert::Pheno is a Perl toolkit for converting phenotypic data between common standardized models, letting you transform records between formats such as PXF (Phenopacket), BFF, OMOP, REDCap, CSV and JSON/JSON-LD either from code or via its command-line interface. It uses mapping files and configurable rules to preserve identifiers, ontological terms and visit/procedure details, includes memory-efficient streaming for large datasets and utilities for fuzzy matching and term mapping, and is designed to slot into pipelines that integrate clinical, research and registry data. The module is actively maintained by CNAG and the author requests citation of Rueda et al. 2024; the most recent releases refreshed the ICD‑10 database and reorganized internal components while adding improved search/fuzzy matching and a number of conversion refinements.

Enum::Declare::Common is a curated collection of ready-made enums for Perl built on Enum::Declare that saves you from retyping common constant sets like HTTP status codes and methods, weekdays and months, ISO country and currency codes, MIME types, CSS colors, timezones, permissions, log levels and more. Each submodule declares proper constants, export tags, and meta objects so you can introspect values, perform exhaustive matching, and validate or coerce inputs easily. The enums are registered as Object::Proto types at load time so you can use enum names directly as slot types with automatic coercion for things like case-insensitive lookups or numeric-to-name conversions. Avoid loading conflicting enums that share the same name across modules by importing only the tags you need, and note that this is the initial 0.01 release of the collection.

subst is a greple plugin that checks and optionally substitutes text in files using a dictionary of pattern-to-replacement pairs, where patterns can be full Perl regular expressions and replacements are plain strings. You feed it a dictionary file or inline data, or pass individual pairs on the command line, and it can report matches, produce statistics, and apply changes with diff, create, replace, or overwrite behaviors. It supports DEFINE named patterns, configurable handling of overlapping or included matches, optional line-folded matching for multi-line cases, and terminal color output. The distribution includes example dictionaries geared toward Japanese text normalization and style guides, so it is especially useful for enforcing style rules, normalizing variants like katakana spellings, or doing large scale, rule-driven search-and-replace across documents.