CPANscan

Dpkg is a small, focused Perl module that provides a set of global variables describing the local dpkg installation and acts as the entry point to the Dpkg Perl module hierarchy. It exposes variables such as PROGNAME and PROGVERSION plus the names of system tools (PROGMAKE, PROGTAR, PROGPATCH) and the canonical dpkg paths (CONFDIR, ADMINDIR, LIBDIR, DATADIR), so Perl programs can discover how dpkg is laid out on the current system. The Dpkg package also organizes access to many related helper modules (control, version, compression, source handling, shlibs and more) used for packaging and repository work. Note that in recent releases the module cleaned up legacy names and removed some deprecated variables, so callers should prefer the documented uppercase variables provided by this module.

Alien::libhisto is a helper module for Perl developers who need the C library libhisto for histogramming, curve fitting, and streaming quantile sketches. It automatically locates an existing libhisto via pkg-config or builds and installs the library with CMake into Perl's shared distribution area so your XS or FFI code can find it. The module plays nicely with ExtUtils::MakeMaker and FFI::Platypus, making it easy to declare a dependency in a Makefile.PL and load the library at runtime. If you are writing Perl bindings or modules that require high-performance histogram or sketching routines, Alien::libhisto removes the pain of managing the native library on users' systems.

Cavil::CLI is a simple command-line tool for submitting a project to a Cavil server so the server can run its standard legal review and report the project's licensing risk, either interactively on a developer laptop or as a CI gate. You configure a server URL and API key once or provide them via environment variables, then run cavil-cli check to upload the working tree (excluding .git and any explicit excludes) for analysis, with options to respect .gitignore, exclude extra paths, set priority and timeout, and to download the SPDX SBOM or NOTICE attribution file. The tool is careful about credentials and large uploads, supports text or JSON output for CI, and can fail the job when the report meets or exceeds a configurable risk threshold. In the most recent release the client was repurposed from a code-search helper into a focused legal-review client so the check command now drives server-side unpack/index/analyze review and returns licensing risk.

App::FuguWeb builds a simple static documentation website from the docs a Perl project already keeps: mdoc manuals, POD sidecars, and Markdown. It runs the standard renderers mandoc, lowdown and pod2man and wraps their output in a shared chrome so you get a single flat output directory with no templating language and no JavaScript. You configure a project with a single .fuguwebrc file using the Fugu::Config grammar to declare pages, manual groups, modules and published keys, then run fuguweb build to produce the site or fuguweb check to validate it. The distribution splits the work into focused modules for config, page chrome, rendering, manuals, indexing, site assembly and checks, and it provides small utilities such as HTML and attribute escaping, directory tree walking and a path_below test. Non-rendered files are copied as assets, the build writes a single stylesheet and uses a temporary staging directory for mdoc sources. App::FuguWeb is ideal if you want a deterministic, low-friction way to publish Perl project documentation without adding templating or client-side complexity.

Acme::Glue is a lighthearted companion module that packages a photographic art project about the Perl community and the code culture that accompanied it rather than providing reusable code. It collects a curated selection of conference and workshop photos from 2015–2025 together with short code snippets and notes, links to the project website and talk video, and metadata about where the images were taken. The material is meant for readers who appreciate Perl history, conference culture, or the intersection of code and photography and is useful if you want a printable snapshot of community artifacts, amusing code fragments, or background for the gallery and talk. This is not a programming toolkit but an archival and presentation vehicle maintained by Lee Johnson on CPAN and GitHub, and the most recent release updated the project description to match the author’s website.

Webservice::Overleaf::API is a compact Perl helper for integrating with Overleaf: it builds official "Open in Overleaf" URLs and data-URIs, produces Git bridge URLs and runs safe Git clone/pull/push commands, and it can optionally (with explicit experimental mode and an Overleaf session cookie) talk to the same web endpoints the Overleaf browser uses to list projects, download project ZIPs, trigger remote compiles, and fetch PDFs or other compile artifacts. The module keeps network and process interactions injectable so you can mock HTTP and Git activity in tests and it intentionally avoids putting Overleaf auth tokens on command lines. Note that the browser-session web endpoints are unsupported by Overleaf and are only available when you opt in because they may change without notice. Recent updates added a bundled command-line tool named overleaf with full help rendered from embedded POD, expanded CLI commands for imports, Git and project actions, and a comprehensive mocked test suite so the distribution can be used and tested without live Overleaf calls.

XML::Feed is a Perl library for reading, creating and discovering web syndication feeds that hides the differences between Atom and several RSS versions. It can parse RSS 0.91, RSS 1.0, RSS 2.0 and Atom and offers a consistent API for feed metadata, entries and dates, converting dates into DateTime objects so you do not have to handle format quirks yourself. It supports parsing from strings, files, filehandles or URIs and can auto-discover feeds linked from an HTML page, and it integrates with LWP::UserAgent for network fetching. You can build, convert and splice feeds, iterate or add entries, and emit XML with as_xml. There are a few compatibility notes documented by the author: you can override the RSS parser class via a package variable but only XML::RSS::LibXML 0.3004 is known to work for parsing, and multi-enclosure support requires XML::RSS 1.44. The module is open source and maintained on GitHub.

File::Raw::XML is a compact, security-minded XML 1.0 and Namespaces 1.0 parser with a built-in canonicaliser designed for cryptographic signature workflows. By default it runs a strict profile that accepts UTF‑8 only and refuses DOCTYPEs thereby removing entity expansion, external DTDs and common XXE or billion‑laughs style attacks, and it offers an explicit full profile that adds DTDs, controlled entity expansion, validation, XInclude and extra encodings when you opt in. It builds a read-only DOM-like tree, supports XPath 1.0, can stream documents with a pull or push reader for low memory processing, and can serialize canonical bytes in Exclusive, Inclusive 1.0 and Inclusive 1.1 modes needed for XML Signature verification. The API includes a direct byte codec, a File::Raw plugin, ID indexing and editing/serialising helpers, and a small C ABI so XS consumers can parse, walk and c14n entirely in C for maximum performance. This is the initial public release.

Alien::Build::Plugin::Build::Xrepo is a plugin for Alien::Build that lets an alienfile install prebuilt packages from xrepo and a wide range of package stores such as vcpkg, conan, Homebrew, conda, apt, pacman, Cargo and others instead of downloading and compiling source. You declare one or more packages (with per-package options like version and kind) and the plugin uses xrepo to export package trees into Alien::Build’s staging area, then translates those trees into the standard runtime properties you expect such as cflags, libs, version and bin_dir and optionally FFI metadata for build_ffi consumers. The plugin isolates failures so a bad package does not stop its siblings, records errors in runtime properties and writes an xrepo.manifest of what actually installed, it fails fast and emits clear errors when the engine or xrepo executable is missing, and it exposes handy helper variables like %{xrepo_cflags} and %{xrepo_libs} for use in recipes. This is a brand new v1.0.0 release providing a straightforward way to leverage existing binary package ecosystems from within Alien::Build.

lazy is a developer convenience module that automatically installs missing Perl modules on demand so you can run someone else’s script without manually resolving dependencies. It hooks into Perl’s module loader and uses App::cpm to fetch and install any module that cannot be found, with options to install globally or into a local lib directory and to pass additional App::cpm flags. You can load it from the command line, from PERL5OPT so test runners like prove pick it up, or from your code and direct installs with -L or by using local::lib first. Do not use lazy in production, and note it only installs modules that are completely missing, it will not upgrade an already installed module that is too old because the hook only runs when require fails. Recent releases raise the minimum Perl to 5.24 and require App::cpm v1 to avoid broken cpm releases and ensure reliable installs.

MIDI::RtController is a Perl toolkit for processing and routing live MIDI controller data with user-defined plug-in filters. You create a controller with input and output device names, add named filters that react to specific MIDI event types or to all events, and run an asynchronous loop that forwards, modifies, duplicates or delays events using simple helper methods like send_it and delay_send. It works from the command line or inside scripts, supports multiple inputs sharing a single loop and output, and is ideal for tasks such as transposing notes, layering voices, remapping controls, building arpeggiators, or logging incoming events. Filters are plain Perl callbacks so you can implement custom mappings and effects easily. Note that input handling runs in a spawned worker process so you should call stop before discarding a controller to terminate that worker.

Alien::Xrepo is a Perl bridge to native package ecosystems that makes it easy to fetch and install shared libraries and runnable tools for use from Perl without touching the system package manager. It drives xrepo and can pull from many third party managers such as vcpkg, Conan, Homebrew, Conda, Cargo and apt so you can obtain libraries like libpng or sqlite3 and tools like ninja, cmake, python or node with a single call. The module handles platform, architecture and build-mode selection, prefers shared builds for FFI consumers, exposes precise paths and compiler flags via a PackageInfo object, and provides an env helper to run installed tools in the right runtime environment. A small on-disk cache avoids spawning xrepo on every call and you can isolate the install root for reproducible project-local stores or export downloads for offline use. If you are writing XS or FFI bindings, automating builds, or need guaranteed tool binaries at runtime, Alien::Xrepo automates acquisition, configuration and introspection so your Perl code or build system can find and use native dependencies reliably.

Alien::Xmake is a thin, user-friendly Perl wrapper around the xmake build tool that helps you locate, download, build, and drive xmake from Perl scripts so you can scaffold projects, configure builds, compile, run tests, package artifacts, and manage C/C++ dependencies without hand-editing build files. Its methods mirror xmake actions so you can call create, configure, build, run, install, package, show, project, lua and many plugin tasks programmatically and capture structured JSON output for introspection with helpers like target_info and lua_json. It also integrates with package management via xrepo and provides Alien::Base helpers for use inside alienfile recipes, plus a small Perl DSL (Alien::Xmake::Project) to generate xmake.lua from code. Recent releases reached v1.0.0, split Alien::Xrepo into its own distribution for clearer separation of concerns, and fixed Windows executable quoting so paths with spaces no longer break CreateProcess, and the module will install a local xmake for you when a system installation is not present.

MIDI::RtMidi::Util supplies simple, convenient helpers for working with real-time MIDI devices from Perl, making it easy to list available input and output ports, open a device by matching part of its name, and stop and close devices when you are done. It exposes input_ports and output_ports to return lists of open port names, in_port and out_port to open a named MIDI::RtMidi::FFI::Device for input or output, and stop_device to cleanly close a device, so it is handy for small scripts, quick prototyping, and simple device selection and cleanup without needing to deal with lower level details.

Pod::Markdown::Githubert converts Perl POD into GitHub-flavored Markdown and builds on Pod::Markdown by adding GitHub-aware tweaks that make rendered docs behave correctly on GitHub. It rewrites internal L</...> links to match GitHub heading ids, lets you embed raw GitHub Markdown with "=for github-markdown" blocks, and redirects Perl manual links to perldoc.perl.org when metacpan would be incomplete. Verbatim paragraphs become fenced code blocks with normalized indentation and proper handling of code that includes backticks or appears inside lists. Syntax highlighting is supported via "=for highlighter language=FOO" and you can set a default language with the hl_language method or constructor option. The module also escapes dollar signs to avoid GitHub treating text as TeX math and prefers asterisk-based italics to match GitHub rendering. Recent notable updates added the hl_language option and fixed a documentation code-block language declaration while including license files.

Alien::OpenCV is an "Alien" distribution that makes the OpenCV computer vision library available to other Perl modules on CPAN by either detecting and using a system install or downloading and building OpenCV into a private location when needed. It integrates with common Perl build and FFI workflows so XS modules, Inline::C/CPP code, and FFI::Platypus consumers can find the headers and libraries without forcing users to install OpenCV themselves. Built on the Alien::Base framework, it is intended to simplify dependency management for Perl bindings to OpenCV.

pplquery is a lightweight command-line client for running OpenSearch PPL queries from a file or standard input and emitting results as a readable table, JSON, or CSV. It can target a cluster directly via flags or environment variables or use named connection profiles stored in a JSON config file to keep endpoint, authentication, TLS, and timeout settings together, and it supports HTTPS with basic auth, password-from-file or environment, custom CA files, and an insecure testing mode. The tool validates connection files strictly, avoids taking passwords on the command line, and includes a companion VS Code extension that runs .ppl files from the editor and shows results inline. It is ideal when you need a simple, scriptable way to run PPL queries against self-hosted OpenSearch clusters; it does not implement cloud provider signing or other auth schemes such as AWS SigV4, API keys, bearer tokens, or mutual TLS.

File::Raw is a high-performance file utility for Perl that gives you fast, low-overhead operations for reading, writing, streaming and inspecting files, with functions exported as file_* helpers such as file_slurp, file_spew, file_each_line and file_mmap_open. It is built for large files and tight loops, offering zero-copy mmap access, direct read/write syscalls, efficient line iteration and a chunked iterator for pull-based parsing, plus a stat cache to avoid repeated syscalls. A flexible plugin system lets you register transforms and record parsers (csv, gzip, json, etc.) and chain byte-level and record-level plugins when slurping or spewing, while streaming callbacks remain memory efficient for truly large inputs. Utility helpers cover common filesystem needs such as copy/move/unlink, mkdir/mkpath, head/tail and platform-optimized native copies where possible. Notable recent work in 0.17 added chunk_iter as a pull-read counterpart to each_line and an include/file_chunk.h C API so XS consumers can read chunks from C without copying.

Perl::Critic::Grape is an add-on for Perl::Critic that enforces a focused set of stylistic and safety rules to make Perl code easier to read and maintain. It insists on explicit parentheses when calling built-in functions and forbids inline do blocks so intent is clearer. It discourages manual ref checks and encourages using sigils to indicate data types while reserving the dereference arrow for method calls. It also enforces consistent return behavior, requires subroutines to be ordered by dependency, prefers array and hash slices for lookup sequences, and bans the implicit topic iterator in favor of named loop variables. If you want a small, opinionated suite of checks to improve clarity and consistency in Perl codebases or team projects, this collection is likely to be useful.

Syntax::Keyword::Dynamically adds a single keyword, dynamically, that you put before a scalar assignment to temporarily swap in a new value and have the original restored automatically when the enclosing scope exits. It acts like a more flexible local because it works with lexical variables and with lvalue functions or accessors as well as package variables, and it guarantees restoration even across exceptions, goto or loop control changes. The module respects tied variables and magic so any GET happens once at assignment and any SET runs at assignment and again when the original value is restored, and hash element assignments will add or remove keys as needed to return to the prior state. It also integrates with async code so values are correctly swapped across await points. Use this when you need reliable, temporary dynamic changes to scalars that survive unusual control flow and async context switches.

Music::Drummer is a tiny, user-friendly alias for the MIDI::Drummer::Tiny module that makes drum-related functionality easier to find by providing a clearer module name and searchable keywords like drum, drums, and drumming. It exposes the same simple API for creating MIDI drum patterns and routines such as count‑ins, so you get the capabilities of MIDI::Drummer::Tiny under the Music::Drummer namespace without added complexity. The package is intentionally lightweight and primarily maintained to track and stay in sync with the upstream MIDI::Drummer::Tiny releases, with occasional prerequisite bumps to match updates.

MIDI::Drummer::Tiny is a compact Perl toolkit for programmatically creating MIDI drum parts and metronomes so you can script realistic drum patterns instead of playing them by hand. It gives sensible defaults for a GM percussion kit, common note durations and time signatures, and handy methods to add metronomes in many meters, patterned beats, fills, flams, rolls and crescendo rolls with optional swing and accent control, then write the result to a MIDI file or use a soundfont for playback. You control bpm, volume, channel and the individual drum patches, and higher-level features like sync_patterns, pattern variation callbacks and an add_fill helper make it easy to generate Euclidean or algorithmic rhythms. Recent releases added a Grooves module and improved handling of shared groove pattern files, including a new swap_pat() helper and refinements to groove naming, making it even easier to reuse and swap built-in rhythmic patterns. If you want to automate drum-score generation, experiment with rhythmic algorithms, or produce quick MIDI drum tracks from Perl code this module is a practical, well-documented choice.

Mojolicious::Plugin::OpenTelemetry is a drop-in plugin that automatically instruments Mojolicious web apps to emit OpenTelemetry traces for incoming HTTP requests. Once installed it creates a server span around each endpoint, injects any propagation data from incoming headers, and records standard HTTP and network attributes such as method, path, scheme, client and server addresses, user agent, query string, response status and error details when applicable. It works with async actions and nested routes and re-raises any exceptions after recording them so your app behavior is unchanged. You can customize the tracer name or let it derive one from OTEL_SERVICE_NAME or the app moniker. Note that the plugin must create a temporary span name containing only the request method before the matching route is known, so sampling decisions will not see the final method+route name; a recent update switched to an around_dispatch strategy to allow instrumenting static responses and nested routes but introduced this tradeoff.

Signature::Attribute::Checked is a small Perl extension that lets you add a :Checked attribute to subroutine parameters so incoming arguments are validated against Data::Checks-style constraints before the function runs. It works with sublike constructs such as Sublike::Extended and accepts an expression that yields a checker from Data::Checks, a Types::Standard constraint, an object with a check method, or a package name that provides check. The checker expression is eval()ed at compile time and the check is applied at each call, throwing an exception and preventing the subroutine body if a value fails. Only scalar parameters are supported and the check runs only once at invocation time, so the parameter may be reassigned inside the routine without further validation. This facility is intentionally experimental and depends on XS::Parse::Sublike, so the API and behavior may change as Perl develops and it does not extend to core parameter syntax, lexicals, or class fields.

Fugu is a collection of Perl modules that package the common plumbing used by OpenBSD-style daemons into reusable components. It gives you daemonization, configuration parsing, logging, PID and control sockets, privilege dropping, sandboxing, signal and child process handling, a simple event loop, IPC tools including an imsg codec and newline-delimited JSON over sockets, and utility pieces like an MQTT subscriber, HTTP proxy, REPL and file/state helpers. The distribution targets single-process server-style programs, requires only core Perl 5.36 with optional CPAN features loaded lazily, and includes a sans-IO Protocol::Imsg implementation. Pick Fugu when you need a ready-made, production-oriented toolkit for building and operating daemon-like Perl services.

Data::HashMap::Shared is a high-performance shared-memory hash map for Linux 64-bit Perl that makes it easy to share keyed data, counters and caches between processes by memory-mapping a file or using memfd/anonymous mappings. It provides several type-specialized variants for integer and string keys and values, optional LRU eviction and per-key TTLs so the same structure can act as a fast cross-process cache, lock-free read paths and futex-based writers for low overhead, atomic counters and CAS operations, sharding for parallel writes, and conveniences like batch ops, cursors, freeze/read-only snapshots and diagnostic stats. Small strings are stored inline and larger values use an arena allocator with explicit sizing, and the module exposes both fast keyword-style functions and normal method calls. It is designed for speed and real-world use but comes with practical cautions about crash-recovery, TTLs tied to the local monotonic clock and PID-based recovery across reboots or different PID namespaces. In the recent 0.20 release inserts now reclaim expired slots and will evict to satisfy arena allocation even on overwrite, and sharded sets now record shard count and route on a different part of the hash which is an incompatible change requiring all processes that share a sharded set to be upgraded together.

WWW::Mechanize::Chrome is a Perl module that controls a Chrome or Chromium browser via the Chrome DevTools Protocol, giving you a familiar WWW::Mechanize-style object to drive real browser tabs. It delegates fetching and rendering to Chrome so you can execute JavaScript, query the DOM with CSS selectors or XPath, intercept and inspect network requests, take screenshots or produce PDFs, and interact with forms and dialogs, making it well suited for scraping modern JavaScript-heavy sites, automated testing, and tasks that require a full browser engine. The module can run Chrome visibly or headless and returns HTTP::Response objects for compatibility, but it does require a Chrome-compatible browser to be installed and still lacks some WWW::Mechanize methods such as full POST support and a few legacy features, so check the docs for limits and quirks.

Loop provides compact, high-level iterators for Perl variables so you can process arrays, hashes, and files with minimal boilerplate. It supplies array iterators that pass the current index and allow in-place modification of the original array by assigning to the parameter, hash iterators that support safe nested looping over the same hash without conflicts, and file iterators that hand you line numbers and text for straightforward line-by-line processing. The interface is lightweight and non-exporting so you invoke Loop::Array, Loop::Hash or Loop::File with the target and a callback subroutine, making it convenient for quick scripts and simple data munging. This is the original 1.00 release.

Amazon::Credentials is a small utility for Perl that finds and returns AWS credentials by trying a configurable chain of providers such as environment variables, container endpoints (ECS, Fargate, Lambda, EKS pod identity), EC2 instance profile metadata (IMDSv2), web identity OIDC tokens, and local ~/.aws config and credentials files, and it provides a simple object API plus a command line helper to format or export the discovered credentials. You can control the search order, timeouts and caching behavior, check token expiration and refresh renewable credentials, and it supports SSO flows, credential_process helpers, and normalization of STS assumed-role ARNs to IAM role ARNs for use with IAM APIs. The module is designed with security in mind so credential values are kept inside closures to avoid accidental leakage via dumps or logs, and logging was recently reworked to further reduce the risk of exposing secrets. Version 1.4.0 also improves SSO handling and always uses regional STS endpoints for web identity exchanges. One current limitation is that it does not automatically resolve chained profiles that use role_arn and source_profile or credential_source in ~/.aws config.

Reaper provides a simple, reliable way to handle child process exits in Perl by installing a $SIG{CHLD} handler that can be used globally or scoped locally to a block. It lets you wrap code in reaper { ... } so any children that exit while the block runs are caught and their exit status recorded, and it supplies reapPid to register specific process IDs to reap and pidStatus to retrieve a recorded exit status. The module supports chaining of handlers so it does not blindly replace existing handlers and it avoids stealing exit codes by only reaping PIDs you register. It does rely on cooperating code not to install conflicting handlers, but otherwise makes preventing zombie processes and capturing accurate child exit codes much more straightforward than ad hoc signal handling.