CPANscan

CXC::PDL::Bin1D is a Perl extension for PDL that provides practical one dimensional binning tools for scientific data such as spectra, radial profiles, or time series. It includes an adaptive binning routine that groups consecutive points until a target signal to noise ratio is reached and supports different error models including Poisson, sample standard deviation, or root-sum-square of provided errors, with options to enforce minimum or maximum bin size and bin width and to fold the final bin into its neighbor. It also offers a numerically stable binning-on-index routine that computes per-bin counts, sums, weighted sums, means, unnormalized squared deviations, and min/max values while handling weights, out‑of‑bounds indices, and multi dimensional threading. The module returns results as PDL piddles and emphasizes stable algorithms for accuracy, making it useful for astronomers and data scientists who need robust, configurable binning and basic binned statistics.

Module::CoreList is a reference database and API that tells you which modules shipped with each Perl release. It ships with the corelist command line tool and a small programming interface so you can query when a module first appeared, whether it counts as a core module for a given Perl and module version, what module versions were bundled with a particular Perl, and how core contents changed between releases. It also exposes hashes with release dates, release families, deprecations and removals, and pointers to upstream maintainers and bug trackers, making it useful to module authors, packagers and system administrators who need to track compatibility and history. The module is actively maintained and regularly updated to track new Perl releases, most recently refreshed for Perl v5.43.9.

BZ::Client is a lightweight Perl client for talking to Bugzilla’s XML-RPC web services, giving you an easy object interface to authenticate, call API methods and manage session cookies without dealing with raw HTTP yourself. It supports username/password or API key authentication, automatic or manual login and logout, optional IP-restricted logins, and a generic api_call method to invoke any Bugzilla API call while accepting HTTP connection options such as proxies, timeouts and SSL verification. The module includes debugging hooks via a logger coderef and an option to dump raw HTTP traffic to a directory, integrates with BZ::Client::Exception for error reporting, and even shows how to connect through a SOCKS proxy. Keep in mind this client targets Bugzilla’s XMLRPC API used in version 5.0 and earlier, so for Bugzilla 5.1 and newer you should look at the newer WebService API and the WebService::Bugzilla client.

Math::MPFR is a Perl binding for the MPFR C library that gives you arbitrary precision, correctly rounded floating point arithmetic from Perl programs, so you can work with bigfloats, special functions, constants and advanced numeric routines with predictable rounding behavior and configurable rounding modes. It wraps almost the entire MPFR API and adds Perl-friendly conveniences such as operator overloading, conversions to and from Perl and GMP types, formatted I/O, random number generators, and helpers for long double, __float128 and decimal float interoperability when the underlying libraries and build options support them. The module requires the GMP and MPFR C libraries to be installed and handles memory for mpfr objects automatically for blessed objects while offering lower-level control when needed. If you need reliable high-precision math, interval-safe rounding or exact conversions between numeric formats, this module is directly relevant. Recent updates add floating-point interchange import/export to memory buffers, better handling of octal input, a new mpfrtoa_subn printer for subnormal values, and build tweaks to improve compatibility on some Linux and Cygwin environments.

Test::Changes::Strict::Simple is a small test helper for Perl authors that enforces strict, semantic validation of traditional CPAN-style Changes files so you can catch common release mistakes before publishing. It provides a single exported test function, changes_strict_ok, which checks file layout and consistency rules such as uniform indentation, no trailing or non-space whitespace, title and version line formats, version string and date syntax, monotonic version ordering (or the reverse with an option), valid calendar dates that are not in the future or before 1987, and other stylistic conventions like whether items must end with a period or require an empty line after a version. The module is intended for release testing (typically run under RELEASE_TESTING in xt/release), accepts options to customize checks and a few runtime arguments including the Changes filename, an expected module_version and a release_today flag, and reports results via Test::Builder. In the latest release the function now throws an exception if you pass module_version as undef, which hardens argument handling.

Net::API::REST is a Perl framework for building RESTful APIs inside Apache under mod_perl. It provides a central request handler that maps incoming HTTP requests to route definitions and user handlers, gives you convenient request and response objects, and captures path variables as endpoint context so you can write handlers that focus on business logic. The module handles CORS and OPTIONS preflight checks, supports API versioning, configurable HTTP methods, content types and languages, and exposes hooks for access control such as network, method and content type checks so you can enforce security policies early. It also includes JWT encode/decode support with options for encryption and selectable algorithms and encodings, plus utilities for payload limits, gzip compression and easy integration with third‑party services. Net::API::REST has built on Apache2::API since v1.0.0 and continues to refine routing and endpoint handling, with a recent improvement to route endpoint handling in v1.2.5. If you run Perl web services on Apache and want an opinionated, extensible toolkit to implement secure REST endpoints, this module is likely relevant.

Git::RemoteURL::Parse is a small Perl helper for identifying whether a Git remote URL points to GitHub or GitLab and for extracting the repository name and the owner or group path. You call parse_git_remote_url with a remote string and it returns a hashref like { service => "github", user => "user", repo => "repo" } or { service => "gitlab", group_path => "group/subgroup", repo => "repo" } and returns undef for unrecognized URLs. It handles common HTTPS and SSH forms including tokened HTTPS URLs, SSH host aliases, and nested GitLab group paths, making it useful in scripts, hooks, or tooling that need to classify or normalize remotes. The recent 0.05 release added and reorganized author and release tests and completed the module documentation.

GitHub::Config::SSH::UserData is a tiny Perl helper for people who manage multiple GitHub accounts with separate SSH keys and store per-account metadata in their SSH config comments. It provides a single function, get_user_data_from_ssh_cfg, which scans your SSH config (default ~/.ssh/config or a file you supply) for Host entries named github-USERNAME and parses the next comment line that begins with "User:" to extract a full name, one or two email addresses and any trailing string. The function returns a hash reference with keys full_name, email, optional email2 and optional other_data so you can programmatically map SSH hosts to account details. Note that it expects the comment to follow the documented format and will raise a fatal error if the host or correctly formatted comment is not found.

sshca is a lightweight command-line SSH Certificate Authority that helps you create a CA directory, issue user or host SSH certificates from public keys, renew certificates, list outstanding certs, and clean up expired ones while letting you tune defaults via a YAML config or environment variables. It is aimed at making short-lived, identity-tagged SSH authentication simple to manage without complex infrastructure, supporting options for principals and certificate-specific flags and letting you read public keys from files or standard input. The tool exposes familiar commands like init, issue, renew and list and includes options for validity windows and dry-run cleanup, so it is useful for teams who want to move from static keys to certificate-based SSH access. The author notes revocation and historical record features are planned and that the current release stores certificate metadata in the filesystem rather than a database, with future work intended to add configurable storage backends such as SQLite or PostgreSQL.

JSON::PP is a pure-Perl JSON encoder and decoder that aims to be compatible with the much faster JSON::XS C implementation while providing a full-featured, configurable interface. You can use simple functional calls like encode_json and decode_json or create JSON::PP objects to control utf8, ascii or latin1 output, pretty printing, relaxed parsing with comments and trailing commas, canonical key sorting, handling of big numbers, various object serialization hooks, incremental parsing of streams, and other behaviors. It ships in the Perl core (since 5.14) and is commonly used as the safe fallback backend for the JSON module when JSON::XS is not installed. Because it is pure Perl it will be slower than JSON::XS and the docs point to JSON::Tiny or Cpanel::JSON::XS if you need a smaller or faster alternative or different compatibility tradeoffs.

App::karr is a small Perl application that implements a Kanban-style assignment and responsibility registry for teams. It helps capture who owns which tasks or cards and makes it easier to assign, track, and audit responsibilities in a lightweight, code-friendly way rather than introducing heavyweight project tooling. The module is suited to developers, team leads, and operations staff who want a simple registry of ownership that can live alongside other Perl tooling. The project is open source on GitHub and welcomes contributions and bug reports.

Restish::Client is a lightweight Perl client for talking to REST-style HTTP APIs, giving you a simple object that wraps a base URI and common request patterns so you can send GET, POST, PUT, DELETE, PATCH and LIST calls with minimal boilerplate. It supports default headers for things like authentication, URI templating with named interpolation, query parameters, JSON-encoded body parameters, raw body uploads with content type, and a thin_request mode for calling LWP directly when you need low-level control. The client can be configured with SSL/TLS options, an optional persistent cookie jar, request-level headers, and a debug mode that can trim tokens, and it returns parsed JSON for 2xx responses while exposing the response code, headers and body for error handling. This module is suitable for scripts and services that need a straightforward REST wrapper without heavy framework dependencies. The initial CPAN release adds a Moo-based interface, comprehensive tests, and the core features above.

Chess4p is a lightweight Perl library that provides core chess functionality for building engines, analysis tools, or board utilities. It offers Board and Move objects that can load and emit FEN, push and pop moves, print an ASCII board, generate legal moves and run perft tests, and handle UCI move input/output for engine integration. The module is practical for developers who need reliable move generation and testing hooks without a heavy dependency stack. Planned additions include SAN input/output and PGN parsing, and at present the author notes the library supports only 64-bit systems. This is the initial 0.01 release by Ejner Borgbjerg.

IO::K8s is a Perl toolkit for representing, validating and serializing Kubernetes API objects so you can build, inspect and emit kube-friendly JSON and YAML from Perl code. It provides typed object classes for core resources, a small DSL for writing ".pk8s" manifests, helpers to load and validate YAML (with optional error collection), and methods to inflate JSON or hashrefs into typed objects and serialize them back to JSON, YAML or plain Perl structures. The module also supports Custom Resource Definitions either by writing simple IO::K8s::APIObject classes or by auto-generating classes from a cluster OpenAPI spec, and it can merge external resource maps such as Cilium so multiple providers can coexist while using apiVersion or domain-qualified names to disambiguate colliding kinds. IO::K8s is designed to ensure Kubernetes gets correctly typed values and to integrate with Kubernetes::REST for API calls. Note that the library was rewritten in version 1.00 with a switch from Moose to Moo, unified list handling and an update to the Kubernetes v1.31 API, so you may need to adjust code when upgrading.

Graphics::Toolkit::Color is a high-level Perl toolkit for creating, converting and manipulating colors as immutable objects, with easy serialisation to and from many common formats such as hex, CSS strings, numeric tuples and named palettes. You can construct colors from names or from values in many color spaces, query or export their values, measure distances between colors, and generate related palettes with operations like mix, invert, complement, gradient and cluster for producing coordinated sets. The API favors a functional style so methods return new color objects rather than mutating the original, and it supports perceptual spaces like OKLAB and CIELUV for smoother gradients and more meaningful distance measures. It also integrates with external color-name schemes via Graphics::ColorNames and provides a handy color() importable constructor. Note that several legacy getter and modifier methods are deprecated and slated for removal in the upcoming 2.0 release. In the most recent updates mixing more than two colors without explicit amounts is handled by equal weighting and a few parsing and documentation improvements were made.

App::Cme provides the cme command line utility for working with configuration data through Config::Model, letting you validate, inspect, edit, dump and script changes to system or application configuration in a consistent, model-driven way. It is useful when you want automated checks or controlled edits of config files, interactive editing via available UIs, or to run small configuration scripts that can read and write config trees and optionally commit changes to version control; run scripts can be written in YAML or Perl and support variables, foreach loops, stashing changes before execution and fine grained commit control including the new modify --commit <msg> option. The tool can export configs as YAML, JSON or Perl, supports multiple backends such as ShellVar and YAML, works with configuration directories and application-specific models, and integrates with Config::Model features for deep checks and sane defaults. App::Cme is open source under the LGPL, maintained on GitHub, and is a good fit if you manage many or complex config files or need repeatable scripted edits, but it is only relevant if you use Config::Model and a Perl-based workflow.

Syntax::Construct is a small utility that lets you explicitly declare which Perl syntactic constructs your code uses when those constructs are not managed by the feature pragma. By naming constructs such as the defined-or operator or non-destructive substitution in a use Syntax::Construct line you get clear, user-friendly error messages on older Perls that tell people which language release introduced the syntax instead of cryptic parse errors, and you avoid needlessly raising your script's required Perl version just to cover a few non-feature items. The module also exposes introduced and removed query functions so tools or install-time checks can determine when particular constructs were added or taken away, which helps when auditing code for backward compatibility or preparing patches for ancient Perls. It does not export symbols and is intended as both documentation and runtime guidance, though behavior can be unsettled on development Perl releases where construct removal is still being tested.

DBIx::Fast is a lightweight DBI wrapper for Perl that simplifies everyday database work by providing easy connection setup and a small set of convenience methods for common tasks. You can connect with a DSN or by specifying driver, database, user and password and then run queries that return results as arrayrefs, hashes, single values or flat lists. It includes helpers for inserts, updates, deletes and a shorthand up method, exposes the last SQL, last insert id and errors, and can write a simple profile log. The module also provides utilities to build WHERE clauses and handle MySQL-style timestamps so you can focus on CRUD logic instead of boilerplate DBI code. It aims to be simple and pragmatic for scripts and small applications, and is distributed under the Artistic License 2.0; note that the author has left a FIXME around one preparation path which suggests a small area may need refinement.

SQL::Wizard is a Perl toolkit for building SQL queries as composable, immutable expression trees that you assemble in code and render to a final SQL string plus a flat list of bind values with a single to_sql call. It treats every piece of SQL as an expression so you can nest subqueries, functions, CASE expressions, arithmetic and window functions anywhere, and it provides clear primitives like col, val, func and raw plus operator overloading for arithmetic to make expressions concise. Queries are immutable so modifier methods return new query objects and let you derive many variants from a base query without side effects. The module covers the full range of common SQL needs including SELECT, INSERT, UPDATE, DELETE, joins, CTEs and recursive CTEs, compound queries, PostgreSQL and MySQL upsert forms and RETURNING, and it uses bind parameters by default for safety while allowing literal SQL when necessary. It follows familiar SQL::Abstract style where syntax for WHERE works as Perl developers expect and it has no non-core dependencies, with dialect-specific rendering reserved for future work and current output limited to standard ANSI SQL.

Dist::Zilla::PluginBundle::Author::ETHER is an opinionated, ready-made bundle of Dist::Zilla plugins by Karen Etheridge that sets up a full build, test and release workflow for Perl distributions. Add [@Author::ETHER] to your dist.ini and you get sensible defaults for gathering files from git, generating README and metadata, running a broad suite of author- and release-time tests, managing version numbers and git tags, preparing and committing release artifacts, and updating GitHub and CPAN metadata. The bundle is tailored for GitHub-hosted projects by default but supports other servers and lets you tweak installer backends, inject plugin prereqs into your metadata, enable airplane mode to avoid networked checks, create a cpanfile, perform fake releases, and control licence and authority metadata. It is designed to be customizable and mint-friendly so new projects start with a robust setup. The latest updates include tweaks to the generated CONTRIBUTING document to address AI contribution guidelines.

Bored is a tiny, whimsical Perl module that offers a handful of playful, no‑op routines for amusement and quick experimentation. You can call the exported bored_one function or instantiate a Bored object and run methods such as pointless, waiting, and tortured to get lighthearted placeholder behavior or to seed test code with amusing stubs. The module is intentionally simple and not meant for heavy production use, and documentation is available via perldoc with bug reports handled through CPAN's RT. This release is Version 0.07, the project began with 0.01, and it is distributed under the Artistic License 2.0.

Acme::AsciiEmoji is a lighthearted Perl module that exports a large set of ready-made ASCII and kaomoji emoticons as simple functions you can call from your code. With names like innocent, shrug, table_flip and hugger each export returns a printable emoticon string so you can easily add expressive faces to command line tools, logs, bots, tests or any script output. It is meant to be a fun, presentation-focused utility rather than a library for data processing, and is useful whenever you want to inject personality or humor into text output.

CallBackery is a Mojolicious-based framework that provides the server-side plumbing for building appliance-style, configurable web frontends. It wires a Mojolicious app to load configuration (from etc/callbackery.cfg or a CALL BACKERY_CONF override), supply a pluggable database interface, expose RPC service endpoints for a rich client, and set security headers on responses. The distribution is aimed at powering a Qooxdoo-style rich client and includes support for forms, tables, uploads and downloads, translations, plugin-based GUI components, YAML configs, session-cookie login flows and async/promise-aware backends so you can focus on application logic rather than HTTP wiring. Recent work continues to polish robustness and compatibility, for example a recent fix prevents attempts to call controller event hooks when no controller is present.

Dump::Krumo is a small Perl utility that produces colorful, human-friendly dumps of variables to make debugging easier. It provides two simple entry points, kx to print a variable and kxd to print and die with file and line details, and it can be configured to return the dump as a string, toggle color output, adjust indentation, suppress all output at runtime so debug calls can remain in production code, and even promote JSON::PP booleans to literal true/false or emit a full stack trace when desired. You can also customize the color scheme via the COLORS hash. If you want prettier, more readable and easily parseable alternatives to Data::Dumper for everyday debugging, Dump::Krumo is a lightweight, configurable option.

AnyEvent::Impl::Prima is a tiny adapter that lets AnyEvent-based timers and callbacks run inside a Prima GUI application by using Prima's own event loop. With this module you can write asynchronous code with AnyEvent semantics and simply call Prima->run to drive both your GUI and AnyEvent timers or watchers, so you do not need a separate event loop or threads to mix GUI and async tasks. It is lightweight and easy to drop into existing Prima programs, making it useful for desktop apps that need network I/O, timers, or other asynchronous hooks managed by AnyEvent. The most recent 0.03 release fixes the test suite to accommodate the deprecation of the single-quote as a package separator.

IO::Stty is a Perl module and command-line utility that implements a POSIX-compatible stty for inspecting and changing terminal line settings from Perl or a shell, letting you query and restore modes on any filehandle such as STDIN. It covers the usual stty operations like toggling echo, switching between raw and cooked modes, adjusting parity, character size, flow control and baud rates, and setting special control characters, and it provides a stty() function for programmatic use plus helpers such as a parser for special-character notations. The bundled stty.pl supports common flags like -a and -g and the module is designed to work with IO::File even though it was not specifically tailored to it. The author notes it is not optimized for speed and advises caution because terminal parameters are low-level and easy to misconfigure, but for tasks like password input, tty testing, or saving and restoring terminal state IO::Stty gives a compact, familiar interface without calling the external stty program.

DB::Handy is a self-contained, pure-Perl embedded relational database that stores tables as fixed-length binary flat files and exposes a familiar DBI-like interface so you can use connect, prepare, execute and fetchrow_hashref without a separate server or XS modules. It implements a robust subset of SQL including joins, subqueries, aggregates, GROUP BY, ORDER BY, LIMIT and basic single-column indexes, and also offers a lower-level engine API for direct file-based operations. Because it has zero external dependencies and runs on very old Perls it is a good fit for small applications, scripts, testing, portable deployments and situations where you want simple relational storage without installing a full database. Note the important design choices and limits: there is no transaction support or AutoCommit control, VARCHAR values are stored as fixed 255-byte fields, there is no BLOB/CLOB support, column order in array fetches is alphabetical, and it is not usable as a DBI driver. This is the initial 1.00 release on CPAN.

String::Ident converts arbitrary text into safe identifiers and URL-friendly slugs. It transliterates Unicode to ASCII, replaces non-alphanumeric characters with dashes, collapses and trims repeated dashes, enforces a configurable maximum length and pads too-short results with random lowercase letters. You can call cleanup as a class method for quick conversions or create an object with new to set min_len and max_len, which default to 4 and 30. The cleanup method accepts an optional second argument to change the truncation limit or -1 to disable truncation. This module is useful when you need predictable, URL-safe identifiers from titles, filenames, or user input.

App::wsgetmail is a small Perl command and library for fetching email from Microsoft 365 mailboxes via the Microsoft Graph API and feeding each message to a local delivery command or mail processing program. You configure it with a JSON file that specifies authentication (client credentials are preferred but username/password is also supported), the mailbox and folder to read, size and body limits, line ending conversion, the command and arguments to run for each message, and whether to mark messages read or delete them after successful delivery. It can be used as a standalone CLI for cron or systemd jobs or embedded in Perl code to iterate and process messages programmatically. The module currently speaks only to Microsoft Graph and reads one folder per run, and it includes options for dry runs and debug output to help with testing. Be aware of Microsoft Graph throttling limits and occasional transient 5xx errors which wsgetmail handles conservatively by treating them as empty successes.