CPANscan

Punk::Queue is a durable, multi-process job queue for Perl with a C core that stores jobs as rows in a database and lets worker processes claim, run and record them atomically for high throughput. It ships with SQLite and PostgreSQL backends, pools DB connections safely across forks, and gives a compact API to register task bodies, enqueue jobs with priorities, delays, parents and dedupe keys, and to dequeue and perform work in workers. The system includes retries with randomized exponential backoff, layered timeouts, per-job logging that survives retries, repair routines for crashed workers and orphaned jobs, simple lease and counted locks, broadcast messages to workers, and list/stats/history endpoints suitable for an admin UI. Because the queue guarantees at-least-once delivery, every task must be written idempotently so reruns do no harm. Recent changes simplified the admin UI to ordinary page loads instead of a vendored SPA and vendored FontAwesome, plus a number of stability and portability fixes in the C layer and supervisor logic.

String::Copyright is a small Perl utility that scans a block of text for copyright lines and rewrites them into a consistent, human readable form. It provides a copyright() function that returns normalized copyright statements and lets you control scanning with threshold, threshold_before and threshold_after options to stop parsing after a number of noncopyright lines. You can also supply a custom format callback to render the output in your preferred style. The module works on decoded Perl strings rather than raw bytes so input must be decoded to the correct encoding before use. It recognizes ASCII and several common misdecoded forms of the copyright sign and will try to normalize them while emitting a warning if misdecoding is detected. This module is handy for tidying license headers or extracting copyright information from source files and other text.

Regexp::Pattern::License is a ready-to-use collection of regular expressions for recognizing and extracting software license names, grants, clauses, and other license-related traits from plain text. Built to fit the Regexp::Pattern convention, it provides pattern objects for individual licenses (GPL, MIT, Apache, BSD and many others), versioned variants, trait fragments like "or later" and "licensed under", combinations and groups, and multiple scope levels from single lines to multi-section blocks. You can drop these patterns into text scanners, search tools, metadata extractors or linting scripts to detect or normalize license references without writing complex regexes yourself. The module is actively maintained and mature, and recent updates tightened several patterns to reduce false positives, improved internal trait patterns and documentation, and fixed a few typos and edge cases such as better disambiguation of MIT versus NTP text.

Punk::Mailer converts a simple Perl hash representing an email into RFC 5322 and MIME compliant message bytes and helps you send them through configurable transports. It assembles text and HTML into multipart bodies, wraps attachments into the proper mixed parts, picks sensible encodings and always uses UTF-8 for text. The module strictly validates addresses and header values to prevent header injection, encodes non-ASCII display names and subjects, streams attachment files in chunks so large files do not blow memory, and can stream the final bytes to a callback if you prefer. You create a Punk::Mailer with a chosen transport like SMTP, sendmail, resend, capture or log, and it checks all options up front so configuration errors fail early. The send method hands a validated message to the transport and returns a result object rather than throwing on delivery issues, making the module a practical choice for web apps and services that need reliable, standards-safe outbound mail and integrates with Punk via Punk::Plugin::Mailer.

OpenMP::Simple is a lightweight Inline::C helper that makes it easy to use OpenMP from Perl by bringing in the compiler and linker settings discovered by Alien::OpenMP and by auto-including a convenience header with macros and helper routines. It provides macros to apply common OpenMP environment variables from %ENV or from the companion OpenMP::Environment module so your Inline C code can set thread counts, scheduling, device selection and related runtime options, and it also offers functions to count, verify, and convert Perl arrays to native C arrays for numeric and string data. This module is most relevant if you embed C in Perl with Inline::C and want straightforward, validated control of OpenMP runtime settings and less repetitive Perl-to-C data handling. Portability depends on a compatible Perl, C compiler and OpenMP runtime discovered by Alien::OpenMP, some conversion helpers are still experimental, and code should avoid calling the Perl API from OpenMP worker threads where possible. Recent releases expanded CI and platform testing, corrected OMP_SCHEDULE, OMP_DYNAMIC and OMP_NESTED handling, improved threaded string conversion safety, and added array counting and verification helpers.

Sys::OsRelease::Lite is a small, dependency-light helper that reads the standard /etc/os-release file and exposes the operating system and distribution metadata to Perl programs so they can detect the platform, distribution family and other identifying fields. It provides a single shared instance (accessible via the exported osrelease() function or class methods) and convenient read-only accessor methods for the standard os-release attributes such as id, id_like, name and version, along with general get/has_attr calls for any nonstandard fields. If no os-release file is present the module does not error and returns empty attributes while platform() falls back to Perl's Config information, making it safe for scripts that must run across Linux, BSD and older Unix environments. Sys::OsRelease::Lite is the same codebase as Sys::OsRelease but packaged to support older Perl releases back to 5.10, so pick the non-lite Sys::OsRelease on modern Perls and use the Lite variant when supporting legacy installations; its minimal setup makes it handy for installers, container tooling and other code that needs to know the host OS.

Sys::OsRelease is a small utility for reading the standard /etc/os-release file and exposing the operating system and distribution details in a simple Perl API, so your scripts can detect distro name, version and related attributes without parsing files yourself. It provides a singleton instance with easy accessors for the standard os-release fields and a platform() helper that prefers common ID_LIKE values and falls back to Perl's Config when no os-release file exists, and it also exports a convenience osrelease() function for straightforward use. The module keeps dependencies to a minimum so it works well in lightweight or containerized environments and there is a Sys::OsRelease::Lite variant packaged for older Perl releases. Recent maintenance releases clarified behavior on systems without an os-release file and fixed a couple of edge case bugs related to configuration initialization and version handling. If you need reliable, low-overhead OS detection in Perl programs, this module makes the common os-release information easy to read and use.

Dist::Zilla::Plugin::Docker::API builds and publishes Docker/OCI images as release artifacts alongside a Dist::Zilla-built distribution, letting you package your Perl project into a container image, apply a set of tags for local verification, and optionally push those tags to a registry during release. It speaks to the container engine via the Docker Engine HTTP API so no docker binary is required and it works with alternatives such as rootless Podman when you point DOCKER_HOST at the engine socket. The plugin runs an early engine-version precheck and can preflight registry credentials for releases, supports configurable Dockerfile name, build args, labels, platforms and tag templates, and exposes switches like build_load, release_push and release_load to control loading and pushing behavior. Registry credentials are resolved only from the auths block of ~/.docker/config.json or DOCKER_CONFIG, so podman’s own auth file and external credential helpers are not consulted. Use this plugin when you want Dist::Zilla to produce and manage container images for development testing and automated publishing as part of your release workflow.

App::Netdisco is an open source, web-based network management application that inventories and maps your switches and routers by collecting SNMP data into a PostgreSQL database and presenting it via a built-in web UI and backend daemon. Network engineers can use it to locate a host by MAC or IP and see the switch port it sits on, change port state or VLAN and PoE settings, run discovery and polling jobs, and produce inventory and topology views for troubleshooting and reporting. It installs on a standard Perl/Postgres stack and can be run in a self-contained user environment or via provided container images, with command-line tools for deployment, discovery and job control and a DBIx::Class API for integrations and plugins. The project is actively maintained and recent releases modernized the frontend libraries, improved SNMP support (including better Cisco WLC handling), and added performance and API refinements, so it is a good fit if you need an open, extensible tool to discover, track and control layer‑2/3 network devices.

WWW::Spotify is a Perl client that wraps the Spotify Web API and exposes catalog, track, artist, playlist and user-library operations as simple methods that mirror the HTTP endpoints. Calls return raw JSON or decoded Perl data structures and there is a convenient get() helper that uses JSON::Path to pull specific values from the last response. The module supports OAuth for user-level actions and provides helpers to build the authorization URL, exchange authorization codes and refresh tokens so you can create and modify playlists, save or remove library items and perform other authenticated operations. You can supply your own LWP-based user agent and tune behavior with options such as auto_json_decode, die_on_response_error and a custom request handler. The author has kept the module current with Spotify API migrations through 2026, consolidating library endpoints and renaming playlist tracks to items; deprecated endpoints are retained with warnings and recent releases added a working authorization-code flow while introducing a breaking change where create_playlist no longer accepts a user_id argument. The module requires Perl 5.24 or newer and includes mocked tests plus optional live tests to help you develop safely.

DBD::Excel is an alpha-quality DBI driver that lets Perl programs treat Excel .xls worksheets like SQL tables so you can prepare and execute SQL against spreadsheets to read, create and update sheets. It leverages Spreadsheet::ParseExcel to read files, Spreadsheet::WriteExcel to write them and SQL::Statement as the query engine, and it maps each worksheet to a table using the first row as column names. The driver supports options to declare temporary or virtual table ranges at connect time, can list Excel files or sheet names, and provides attributes to skip hidden rows and control case sensitivity. Some DBI features are not implemented, AutoCommit is always on, and the module currently lacks date/time and formatting support and only handles single-table SELECTs, so it is best suited for simple SQL-style access, scripting tasks and lightweight Excel import/export work rather than complex joins or full-featured Excel formatting.

JSON::Schema::Modern is a Perl evaluator for JSON Schema that lets you validate JSON data or Perl data structures against modern JSON Schema drafts, including the current 2020-12 draft, with support back to draft-4. It makes it easy to load and register schema documents, run validations that return a rich Result object containing errors, annotations and optional default values, and to customize behavior with options such as strict mode, short-circuiting, format and content validation, and caching for large documents. You can extend it with custom format validators, media-type decoders and encodings, add custom vocabularies for metaschemas, and integrate it into workflows like OpenAPI validation. The module is actively maintained and recent releases improved reference handling by tracking unresolved remote references for later verification and fixed an error in reference checks. The author notes some practical limitations around Perl type mapping and untrusted schemas, so it is best used with decoded JSON or trusted schema sources.

Complete::XWindowManager is a tiny helper library for adding autocompletion around X Window System targets. It exposes two non-exported routines that return completion candidates for existing X window IDs and for window titles, each intended to be called with the current word being completed and plugged into the Complete framework or into custom completion code. If you are building command line tools or shell completions that need to let users pick windows by ID or by title, this module supplies the simple lookup routines to generate those suggestions.

PAGI::FastAPI is an asynchronous, FastAPI-inspired micro-framework for modern Perl that gives you non-blocking request handling on the PAGI spec, Type::Tiny driven validation for query, body and path parameters, a simple dependency injection style, and automatic OpenAPI 3.1 and Swagger UI documentation so you can build typed, documented HTTP APIs quickly. It includes route helpers for the usual verbs, WebSocket and Server-Sent Events streaming, middleware and CORS integration, pluggable authentication via dependencies or the companion PAGI::FastAPI::Security distribution, rate limiting, bot protection, CSRF helpers, response helpers for redirects and files, and a lightweight async queue facade. The recent 1.7.0 release adds proper RFC 7578 multipart/form-data parsing with form_data() and uploaded_files() context helpers, a $c->background API for fire-and-forget async tasks that continue after a response is sent, richer per-route OpenAPI metadata and Swagger UI customization options, plus a file response helper. Note that uploaded files and file_response currently read file contents into memory so you should plan request size limits accordingly. If you want a modern, type-safe, async-first framework for building Perl microservices with built-in docs and streaming support, this module is worth exploring.

Object::Proto is a fast, alternative object system for Perl that replaces ordinary bless-based objects with compact, array-backed objects and optional prototype chains while keeping normal method dispatch, isa and can intact. You declare classes with object or Object::Proto::define and list typed properties with modifiers like required, readonly, default, lazy, builder, predicate, clearer, weak and private, and the module generates very fast accessors and constructors that accept positional or named arguments. It supports inheritance, multiple inheritance, roles, method modifiers, BUILD and DEMOLISH hooks, singletons, cloning, lock/freeze semantics and importable function-style accessors for maximum throughput. Types include several built-ins and can be extended from Perl or registered at the XS/C level for near-zero runtime cost. If you need compact, high-performance objects with rich attribute semantics and familiar Perl method behavior, Object::Proto is a practical choice.

ClamAV::Clamd is a lightweight Perl client for talking to a clamd antivirus daemon so your app can ask a local scanner to check uploads without linking libclamav or carrying the signature database. It supports scanning raw bytes, file paths, or open file descriptors and can hand a descriptor to clamd so the scanner reads a file without needing filesystem permission to the path. The module provides both blocking convenience methods and a small non‑blocking state machine you can drive from an event loop, and every scan returns a Verdict object with four distinct outcomes: clean, infected, unscannable, or error, which helps you avoid treating failures as safe. It prefers UNIX domain sockets for descriptor passing, exposes useful controls for timeouts and size limits, reports structured error codes when things fail, and can tell you whether fd‑passing actually works on the platform. Recent fixes make live test runs opt‑in to avoid talking to someone else’s daemon and ensure commands disabled in clamd (version, stats, reload) return a proper ERR_UNAVAILABLE response rather than being misinterpreted as data.

Hyperman is a production-focused PSGI web server for Perl that combines a prefork supervisor with a per-worker XS event loop to serve synchronous and asynchronous apps with low overhead. Handlers can return Hyperman::Future objects so you can await timers or IO without blocking the worker, and the server exposes timers, readiness watchers, and a C ABI so other XS modules can integrate directly. It includes built-in features you expect from a modern server: fast C-side access logging, optional gzip compression with tunable level and thresholds, TLS with SNI and client certs plus kernel TLS when available, HTTP/2 support, multiple listeners and redirect helpers, and a safe spill-to-temp-file strategy for large request bodies. For pool-wide coordination it provides a shared memory pub/sub message bus and a fork-shared denylist and fixed-window rate limiter so limits and blocks are consistent across workers. The implementation is intentionally XS-heavy for performance and exposes hooks for per-worker startup and in-place TLS reloads. If you need a high-throughput PSGI server with async-friendly primitives, per-worker isolation, and low-latency inter-worker messaging, Hyperman is highly relevant; note that some backends such as io_uring have platform tradeoffs and compression costs CPU so they are opt-in or conservative by default.

App::GHGen is a command line tool that generates, analyzes, and optimizes GitHub Actions workflows so you can keep CI fast, secure, and up to date with minimal manual work. It can auto-detect your project type or let you choose and customize templates, then produce ready-to-run workflows that include caching, concurrency, appropriate permissions, and sensible test matrices. The built-in analyzer scans existing workflows for performance, security, cost, and maintenance issues, provides CI minute cost estimates, and can apply safe automatic fixes or open pull requests with the suggested changes. It also runs as a GitHub Action to comment on PRs, create fix PRs on a schedule, or enforce workflow quality as a CI gate. Targeted at maintainers of single repositories or many projects, it supports Perl and other common ecosystems and requires Perl 5.36 or later. Auto-fix is conservative and will skip complex project-specific logic, so reviewing changes before merging is recommended. The tool is open source and available on GitHub under the GPL2 license.

Punk is a batteries-included MVC web framework for Perl that provides a compact DSL to declare routes, controllers, static mounts, websockets, server-sent events and OpenAPI-mounted APIs, together with built-in support for sessions, CSRF, CORS, headers, caching, auth, named routes and testing. The application is compiled and frozen at to_app time so routing, guard chains and handlers run very cheaply and many configuration errors are caught at boot, and the supplied CLI can scaffold a working app, mount OpenAPI specs, run a dev server and exercise the app with an in-process test client. It also offers async-friendly primitives so handlers can return futures without pinning workers on compatible servers, a simple key/value cache with compute-if-miss, a cross-worker publish/subscribe bus for ephemeral notifications, and a C ABI for low-level observers. Punk intentionally delegates compression and some transport details to the PSGI server and validates options aggressively at boot to fail early. Be aware that the pub/sub bus is at-most-once and not durable, max_body enforces a request-length policy rather than providing memory isolation, and static file stat caching uses a short TTL that can delay noticing rapid edits. If you need an opinionated, production-ready Perl framework that favors fast, predictable dispatch and rich built-in features for web apps and APIs, Punk is a strong candidate.

Database::BI is a Mojolicious web application that lets you explore plain flat data files as styled, sortable, reorderable HTML tables so you can inspect CSV, PSV, XML and SQLite data in a browser without building a custom pipeline. It scans a configurable data directory to present file cards, offers a filesystem browser and drag-and-drop uploads, and saves column order and sort state in localStorage for a smoother interactive experience. You can perform repeatable left joins across files, apply server-side filters, inspect column metadata via JSON APIs, import HTML tables from public URLs, and export the current logical view as RFC 4180 CSV or a single-table SQLite file either as a download or written to disk. Be aware that the app is read-only, the join engine is an in-memory O(n*m) hash join so very large files may not fit comfortably in RAM, and the underlying file-extension support is limited to csv psv sql and xml which must match filenames exactly. This is the initial CPAN release and is provided under the GPL2 license.

Cron::Toolkit is a Perl module for parsing, describing and evaluating cron schedules with full Quartz 7-field support plus handy extensions like combined day-of-month and day-of-week logic, wrapped weekday ranges, and an internal Monday=1 weekday convention. It understands time zones and handles DST exactly like Quartz, produces human-readable English descriptions, can parse whole crontab files with environment expansion, and provides methods to get the next or previous occurrence, test a timestamp, dump the parsed abstract syntax tree for debugging, and convert between normalized and Quartz strings. The distribution ships with over 400 data-driven tests covering leap years, DST transitions and many edge cases, so it is a reliable choice when you need production-grade scheduling, accurate date calculations across time zones, or tools to inspect and reason about complex cron expressions. If you work with scheduled tasks or need precise control and debugging of cron rules, this module is likely relevant.

Alien::TALib is a helper module that downloads, builds and exposes the native TA‑Lib technical analysis C library so other Perl modules can find and link against it. It follows the Alien::Base/Alien::Build approach and provides simple methods like cflags and libs that you call from Build.PL or Makefile.PL to add the right compiler and linker flags when building Perl bindings such as PDL::Finance::TA. The distribution targets Unix‑like systems and is not supported on native Windows except under Cygwin or MSYS. Recent updates improve download reliability for the upstream zip and avoid probing older TA‑Lib installs on BSDs, making installation more robust across platforms.

Cavil::CLI is a command-line tool that checks your git change set or a directory against Cavil's indexed corpus of open source and commercial code to identify known files, report their licenses, and flag provenance or licensing risk. It is designed for use on a developer laptop and in CI pipelines, supports saving or sourcing a server URL and API token, and can output human readable text or machine readable JSON. The tool scans the current diff by default or an entire tree on demand, can limit checks to staged changes or a specific ref, and offers options to exclude packages or paths, skip hidden files, and control when the command should fail based on a configurable risk threshold. Use Cavil::CLI to catch reused code and licensing concerns early in development and automation workflows.

Plack::Middleware::OpenTelemetry is a Plack/PSGI middleware that adds OpenTelemetry tracing to your Perl web application by automatically creating spans for incoming HTTP requests. It extracts W3C trace context, records standard HTTP attributes such as method, status code, client and server addresses, full URL, user agent and response size, and it supports both synchronous and streaming responses while recording exceptions and setting span status. You can configure whether client errors (400–499) count as errors and supply custom resource attributes like service version or deployment environment. The middleware honors standard OTEL environment variables for exporter and service name and integrates with your OpenTelemetry SDK and exporters. Use it to get standards-compliant, out-of-the-box distributed tracing for Plack-based apps.

XS::Tutorial is a compact, example-driven guide for learning Perl XS that helps Perl programmers bridge Perl and C code. It is organized into three parts that walk you through passing and returning basic C values, handling multiple return values and arguments, and using common utility routines you will need when writing xsubs. The distribution also points to essential further reading and tools, including online XS guides, the Manning book "Extending and Embedding Perl", perldoc pages for perlxs, perlapi, perlguts and related topics, ExtUtils::MakeMaker for build options, Devel::PPPort/ppport.h for compatibility, and the Perl source for deeper investigation. If you need practical, hands-on examples to get started extending or embedding Perl with C, this tutorial is a useful starting place.

Business::ISBN::Data is a data-only companion for Business::ISBN that packages the ISBN Agency's RangeMessage.xml publisher and group ranges so Business::ISBN can validate, split, and format ISBN-10 and ISBN-13 values. You normally do not load it directly because Business::ISBN loads it for you, but the distribution also embeds default data and ships a copy of RangeMessage.xml. If you need newer data you can point the module at an alternate RangeMessage.xml by setting the ISBN_RANGE_MESSAGE environment variable or dropping the file in the current directory, and if no file is found it falls back to the built-in data. The lookup data live in %Business::ISBN::country_data and include a _source entry showing where they came from. This module requires Business::ISBN 3.005 or later to accommodate an ISBN-13 data-structure fix, the project is hosted on GitHub for updates and contributions, and the data are refreshed regularly with recent maintenance including a fix to avoid unintended autovivification when reading the environment variable.

App::pod2gfm is the backend for the pod2gfm command line tool that converts Perl POD documentation into GitHub Flavored Markdown using Pod::Markdown::Githubert. It handles parsing command-line options and setting up input and output filehandles, supports writing to multiple output files without overwriting existing files, and defaults to UTF-8 rather than handling various encodings. Errors are reported to STDERR and the run method returns a nonzero exit status on failure. The latest fixes ensure that reading from standard input with the automatic output option writes to STDOUT instead of creating a file named "-.md" and add robust error handling so conversion errors are caught and reported cleanly.

Math::Histo::PDL bridges the Perl Data Language (PDL) and Math::Histo so you can build, fill and export 1D and 2D histograms directly from PDL piddles with minimal overhead. It provides convenient functions like hist1d and hist2d and attaches methods such as fill_pdl, to_pdl, counts_pdl and axis/center exporters onto Math::Histo objects, supports optional weights and error tracking, and exports counts, edges, centers and error arrays back to PDL. The module is tuned for throughput and can perform zero-copy ingestion of contiguous double piddles by passing their native C buffers into Math::Histo’s optimized core, while automatically coercing or materializing non-double or non-contiguous slices when needed. If you work with large numeric arrays in PDL and need fast histogramming or easy round trips between PDL and Math::Histo, this module will be very relevant, just ensure your hot-path piddles are double and physical to get maximum performance.

Math::Histo is a high-performance Perl XS wrapper around the libhisto C library that gives you fast, memory-safe 1D and 2D histogramming, streaming quantile sketches (DDSketch), online Welford moments, and non-linear curve fitting via Levenberg-Marquardt. It supports uniform and variable-width bins, weighted fills with optional sum-of-weights-squared bookkeeping, and very fast batch ingestion from Perl arrays or zero-copy packed 64-bit float buffers to exploit SIMD acceleration. The module exposes a rich set of statistical tools and convenience features including mean, variance, median and quantiles, mode and peak properties, skewness and kurtosis, rebinning and arithmetic operators, two-sample distances and hypothesis tests, and model fitting, plus compact binary and JSON serialization for storage or transport. If you need production-grade histogramming or summary statistics in Perl with C-level throughput and interoperability with native numeric buffers, Math::Histo is a solid choice.

Alien::libhisto makes the C libhisto histogramming, curve‑fitting and streaming quantile sketch library easy to use from Perl by locating a system install via pkg-config or building and installing a bundled copy with CMake into Perl's shared distribution directory. It is intended for Perl modules that call libhisto from XS or via FFI and integrates with common build systems so your Makefile.PL can pull in the library and your FFI::Platypus scripts can load it with dynamic_libs. Installation is automatic and portable across platforms, and recent updates synchronize the bundled libhisto to v0.3.0 while improving cross‑platform builds with fixes for Windows/MSVC, AArch64/ARM compilation, FreeBSD Clang issues, and support for the CMake NMake generator.