CPANscan

Scalar::ValueTags::LineageTracking lets you attach, propagate, and collect source metadata on Perl scalar values so you can build data lineage for pipelines and tools like OpenLineage. You instantiate a tracker with tag_type 'string' (the default) or 'ref', then add or set source tags when data enters your system and those tags are carried forward automatically whenever new values are derived; you can retrieve or clear tags when data leaves your system. String tags are de-duplicated by their serialized text so you should produce canonical strings, while ref tags are de-duplicated by reference identity and therefore require reusing the same Perl reference for identical tags. The module exposes add_data_sources, set_data_sources, get_data_sources and clear_data_sources (which returns prior tags for reporting). Recent changes simplified the API by pluralizing the add/set methods and making clear_data_sources return previous sources, replacing the old get_and_clear behavior.

Table::Readable provides a tiny, human-editable text format and a small Perl API for storing and manipulating simple tables of key/value rows in UTF-8. Files consist of blocks of "key: value" pairs separated by blank lines and are read into Perl as an array of hashrefs, with simple rules for keys (spaces become underscores) and multiline values delimited by lines beginning with "%%". The module can read and write these tables, append rows, sort files, and build an index hash by a chosen key while optionally returning the original order, and it preserves leading and trailing whitespace via backslash escapes. The format intentionally avoids nesting, extra syntax, or complex escaping so it stays easy to edit by hand, and recent changes (v0.06) added an append_table function and a noslash option to control backslash handling. If you need a lightweight, human-friendly way to keep machine-readable lists or translation text files, this module gives a stable minimal parser and writer with Emacs and Go support available in the project repository.

WebService::Mailgun is a lightweight Perl client for the Mailgun HTTP API that lets Perl applications send messages and manage basic Mailgun resources without dealing with raw HTTP calls. It supports sending plain and MIME messages including attachments, managing mailing lists and their members, querying events with polling and fetching stored messages, and basic template operations with partial template support. You can configure the API key, domain and region (US or EU), and choose whether API errors raise exceptions via RaiseError, while error and error_status helpers give easy access to failures. Several Mailgun endpoints are not yet implemented, for example domains, stats, tags, suppressions, routes, webhooks and full email validation, so this module is best when you need straightforward sending, list management and event access from Perl. Recent releases improved testing by reading credentials from environment variables and migrated continuous integration to GitHub Actions.

DB::x is a tiny debugging helper that lets you drop lightweight breakpoints into Perl code without changing the surrounding logic, either by inserting DB::x to unconditionally stop execution or by using DB::x 'label' so the pause only happens when $DB::x{'label'} is set true from your main script. This makes it easy to toggle breaks for code paths that run frequently because you avoid adding per-call checks, and it integrates with the debugger hooks so you can control labeled breakpoints at runtime. Recent releases added an explicit conditional-debugging form (DB::x 'Feature') and several debugger command improvements, and the module requires Perl 5.12.0 or later.

POE::Component::Server::JSONUnix is a lightweight, event-driven server that listens on a Unix domain socket and exchanges newline-delimited JSON request/response messages, making it a simple local RPC or control endpoint for daemons and command-line tools. Built on POE, it exposes a pluggable command dispatch table you can populate at startup, add to at runtime, or provide by subclassing, and handlers may reply synchronously or asynchronously using a context object that carries the request and reply methods. Messages are single-line JSON objects with an optional id for correlation and the server includes handy built-ins like ping and commands for discovery. Security is handled both by Unix socket permissions and by an optional ownership-based authentication handshake that verifies a client by the owner of a temporary file, and you can enable a per-command allow/deny policy based on users or groups. The recent 0.1.0 release adds the auth_start/auth_verify handshake, a POE-based client and a simple blocking client, and the flexible permissions layer, so if you need a compact, extensible way to expose local control APIs on Unix this module is a strong candidate.

Stats::LikeR brings a rich set of R-like data frame operations, statistical tests and modeling tools to Perl with many performance-critical routines implemented in XS so common tasks run quickly and with low memory overhead. It understands multiple table shapes (array-of-hashes, hash-of-arrays, array-of-arrays and hash-of-hashes) and supplies data I/O and wrangling helpers such as read_table, write_table, view, melt, pivot_table, assign, concat and merge alongside numerical and inferential routines including lm, glm, aov, coxph, t_test, wilcox_test, chi-squared, Fisher, ROC/AUC, ROC DeLong CIs, ANOVA/oneway tests, survival analysis and many effect-size and post-hoc utilities. The API is designed to feel familiar to users of R and pandas so you can group, aggregate, reshape, bin, interpolate or join tables and then run the usual statistical summaries and tests without leaving Perl. Recent work focused on ergonomics and speed: p_adjust now accepts whole data frames and returns corrected values in the same shape, merge was reworked for much lower memory use and faster joins, and new helpers h2aoh / aoh2h make it easy to fold and unfold plain hashes into two-column tables. Note that a small incompatible change was introduced upstream: the ad-hoc '?' / 'h' help argument that some Perl wrappers previously accepted was removed in favor of the dedicated h() printer and write_table now defaults to not emitting row names unless requested. If you write Perl and need fast, R-like data manipulation and statistical routines without switching languages, this module is likely highly relevant.

Hash::SharedMem provides a fast, file-backed key/value store that lets multiple processes on the same host share mutable data by memory-mapping files, so you get low-latency interprocess communication without blocking. Keys and values are limited to octet (Latin-1) strings, though you can store complex Perl structures if you serialize them first with something like Sereal. The API gives handle-based access with explicit read/write modes, atomic single-key operations (including get-and-set and compare-and-set), snapshot handles for consistent read-only views, and whole-hash helpers for listing keys, counting items, and estimating storage. It also offers maintenance calls to idle or tidy a handle and per-handle event counters useful for profiling. The module is designed for cases where the dataset fits in RAM or a memory-backed filesystem, so it is ideal for local caches, counters, or daemon-shared state, but performance will suffer if the data is mostly on disk. Creation is not atomic and file ownership and permissions can be awkward in multiuser scenarios, and the on-disk files are not guaranteed to survive an OS crash in a consistent state.

Backblaze::B2V4 is a straightforward Perl client for Backblaze B2 Cloud Storage that lets you create buckets, upload and download files, list and inspect files, and manage bucket and file versions using the B2 V4 API. You instantiate a client with your application key and key ID and then use simple methods to upload small files or large files, download by file name or GUID, create or delete buckets, retrieve upload URLs and tokens, and make custom API calls via a generic send_request method. The distribution also ships a b2_client command line tool for quick get and put operations and defaults to enabling Backblaze server side encryption for new buckets. If you already use S3 tools note that Backblaze offers an S3 compatible API but this module targets the native B2 API. Recent fixes corrected an upload result bug and updated the CLI to display the new file GUID, and the installer can optionally test your credentials by attempting a sample download when provided with environment variables for a test file.

Google::ISBNNumbers is a tiny Perl module that fetches basic book metadata from the Google Books API when you give it an ISBN. You create the object with your Google API key and call lookup_isbn with an ISBN to receive a hashref containing fields like title, author_name, description, publication_date and cover_link. It is designed for simple scripts and tools that need a quick, reliable ISBN-to-metadata lookup without scraping or heavy dependencies. You will need a Google API key from the Cloud Console and for tests you must set that key in the GOOGLE_API_KEY environment variable. Note that a recent change removed the included test API key, so you now supply your own key for testing.

CGI::ACL is a compact Perl module for deciding whether a web client may run a CGI script by checking the client IP address, CIDR ranges, country of origin and whether the request comes from a major cloud provider. You can build an allowlist of IPs or CIDR blocks and switch to default-deny for countries with deny_country('*') while using allow_country() to whitelist specific ISO country codes. It can call out to CGI::Lingua to resolve country codes and it can detect cloud hosts using reverse DNS with forward confirmation, with the cloud block taking precedence over explicit IP allows. The all_denied method performs the checks and returns 1 to deny or 0 to allow, and the API supports runtime configuration via Object::Configure and method chaining. IPv4 and IPv6 are supported and DNS lookups use a synchronous timeout on non-Windows systems. Note that invalid IP strings are stored verbatim and ignored at lookup time and that VPNs or proxies can defeat IP-based controls.

Data::Text is a small object-oriented Perl helper for building and manipulating text in a cleaner, chainable way than raw scalars. It wraps common string operations into methods you can chain, so you can create or clone text objects, set or append strings or arrays, trim whitespace, replace words, change case, compute length, join lists with natural conjunctions and compare or stringify objects with overloaded operators. It accepts plain strings, arrays or other Data::Text objects as input and is handy when you want clearer, composable text handling in scripts or modules. The author notes limited Unicode/UTF-8 support historically but recent releases improved UTF-8 behavior for length and case methods and the current 0.20 release modernizes the codebase and testing while refining configuration calls.

DesktopWorkspace is a small Perl specification for describing what windows, applications, files, directories, and browser tabs should be opened to set up a desktop workspace. It expresses a workspace as a simple hash with an array of items where each item is exactly one of a URL, file, directory, or a program by name or path, and it includes handy flags such as new_browser_window, new_file_manager_window and a KDE activity name so tools can open things in the right context. The spec also supports grouping related items into the same Firefox or Dolphin window via firefox_window_num and dolphin_window_num so presets can recreate multi-window layouts, and it is intended to be implemented by modules under the DesktopWorkspace:: namespace that define presets like Coding or Writing. Note that a single specification currently targets one KDE activity and that the 1.x series is marked unstable. In the recent 1.0.1 release the maintainer made a backward-incompatible rename from app_name/app_path to prog_name/prog_path and added the window grouping properties and the new_file_manager_window option to give finer control when restoring a workspace.

Desktop::Workspace::Util is a compact Perl helper library for discovering and using DesktopWorkspace specification modules from scripts and tools. It gives you functions to locate and instantiate a workspace module and to list or open workspace items such as files, directories, programs and URLs with flexible filtering by tags, type, query and shuffle options. Open operations return an HTTP-like enveloped result with status codes and metadata so callers can handle success and errors predictably, and they support useful features like a dry-run simulation and KDE activity switching. The helpers are not exported by default but can be exported when convenient. Recent changes added a dry-run mode, a reuse_window option for opening items, and compatibility updates to DesktopWorkspace 1.0.1.

App::XWindowManagerUtils is a small command-line toolkit for inspecting X Window Manager windows on KDE desktops, providing utilities to list managed windows and to find the KDE activity associated with a given window. The package includes list-xwm-windows, which can display KDE activity names or GUIDs for each window, and get-xwm-window-kde-activity to retrieve the activity for a specific window, making it handy for desktop automation, window-management scripts, or troubleshooting. Recent updates refactored common routines into a separate Desktop-XWindowManager-Util distribution and added options and improved searches so activity names and GUIDs can be queried more flexibly. Source and further details are available from the project page and GitHub repository.

App::KDEActivityUtils is a small collection of command-line utilities that make it easy to inspect and control KDE Activities from the shell or from scripts. The tools let you list available activities and get or set the current activity with short aliases like getkact and setkact, making it simple to automate workspace changes or integrate activity-aware behavior into your workflows. The distribution relies on Desktop::KDEActivity::Util for backend calls and serves as an alternative or wrapper around kactivities-cli for users who prefer tiny, focused CLI utilities. If you use KDE Activities and need straightforward command-line access or scripting hooks, this package is relevant and convenient. Note that in the latest release the move-windows-to-kde-activity utility was moved into App-XWindowManagerUtils, and the project source and docs are available on MetaCPAN and GitHub.

Acme::Shotgun is a playful object-oriented Perl module that modifies plain text files by "shooting holes" through them according to selectable shotgun types and ammunition patterns, letting you choose double-barrel or pump action and birdshot, buckshot, or slug to produce different damage patterns. The module keeps magazine state on the object so you can reload, check remaining rounds, and fire at a target file with each shot optionally announcing "POW!" and updating the file unless you run in debug (dry-run) or quiet modes. It works on existing plain text files up to 1 GB, provides simple methods for new, reload, check, and fire, and is useful for whimsical text transformations, demo code, or testing file-processing behavior.

Test::Mockingbird is an advanced mocking toolkit for Perl test suites that makes it easy to replace or wrap functions, spy on calls, inject fake dependencies, intercept constructors, and even override CORE builtins for code compiled after the override. It supports before/after/around wrappers, LIFO stacking of mock layers, scoped guards that automatically restore, and convenience helpers such as mock_return, mock_exception, mock_sequence and mock_once, plus call-order assertions and diagnostics to inspect active layers and the call log. Mocks and injections are reversible with unmock, restore and restore_all so tests can layer behavior and then clean up, and spies record calls while still letting the original run. The author documents some practical limitations such as symbol-table vivification causing Package->can to appear truthy after unmocking, prototype-mismatch warnings when spying on prototyped subs, no support for nested deep_mock scopes, and non-thread-safe internal state. If you write Perl unit tests and need flexible, layered mocking, dependency injection and call verification, this module is a full-featured option.

Proc::ProcessTable::piddler is a Perl helper that generates a compact, human-friendly dump of what a process holds open and where it sits in the system, including open files, anonymous and named pipes, unix sockets, shared memory objects, linked libraries, network connections, and container or FreeBSD jail metadata. You create an object with a small options hash and call run with one or more PIDs to get a ready-to-display string, and the module provides many toggles to reduce noise, control address resolution, deduplicate repeated descriptors, and show peer processes or pipeline chains. It is aimed at system administrators and developers who need to inspect processes for debugging, auditing, or troubleshooting, and it formats sizes and aggregates shared memory to make reports easier to read. In the recent 0.3.0 release pipe chains are shown by default, far ends of pipes/FIFOs/unix sockets and shared memory are reported, open-file sizes are humanized, shared memory is rolled up with a total reported, and container and jail details are exposed.

Config::Abstraction is a lightweight configuration layer for Perl that merges settings from in-memory defaults, multiple file formats (YAML, JSON, XML, INI, TOML), environment variables, and command line arguments with a clear, predictable precedence so you can keep sane defaults in code and override them per-deployment or per-run. It auto-discovers layered files like base.yaml and local.yaml, understands an environment name to load environment-specific variants, accepts a data hash for programmatic defaults, and provides dotted-key access plus optional flattened keys for simple lookups. Environment variables use a prefix and double underscores to denote nesting so you can override nested values without editing files, and command line switches are consumed to give the highest precedence for CLI tools. The module includes helpers to inspect where individual keys came from, methods to prefer a value from a specific source, optional lazy loading to defer I/O, and a built-in AES-256-GCM encrypt_value facility for storing ENC[...] tokens in configs and decrypting them at read time when an encryption key and CryptX are available. It can also fetch remote configuration directories over SSH using the Newcastle Connection "/../host/path" convention when File::Slurp::Remote is installed. Be aware of a few limitations documented by the author such as the inability to escape the separator character in keys, Windows environment variable case issues, and the fact that returned hashrefs are mutable because Data::Reuse fixation is disabled. If you need a predictable, multi-format, layered configuration system with environment and CLI overrides and optional secret handling, Config::Abstraction is a practical choice.

Reverse::Proxy is a lightweight PSGI application that turns any PSGI server into a configurable reverse proxy by forwarding incoming requests to one or more upstream HTTP backends and returning their replies. You can forward every request to a single upstream, route by path-prefix to multiple backends, or provide a resolver callback to pick the target dynamically per request. It uses the Fetch client and reuses a keep-alive connection pool per worker, supports optional streaming of response bodies so large downloads and event streams do not buffer, and tunnels Upgrade requests such as WebSocket connections when the server exposes psgix.io. Standard proxy behaviors like stripping hop-by-hop headers, appending X-Forwarded-* headers, preserving multi-valued response headers, and returning 502 on unreachable backends are handled for you. When run on a server that advertises nonblocking features such as Hyperman, Fetch runs on the worker event loop and many concurrent proxied requests are served without extra threads or processes, while on other servers requests are proxied with blocking Fetch calls. Note that Upgrade tunnels are blocking and require a server that provides psgix.io, so they occupy one worker for their lifetime.

Datafile::Array is a lightweight pure-Perl toolkit for reading and writing simple delimited text files that makes common CSV and TSV tasks easy without adding compiled dependencies. It handles quoted CSV fields including escaped quotes and multi-line records, supports automatic or explicit header lines and an H/R prefix convention, can trim values and filter records by simple patterns, and can load data into arrays of hashes or into keyed hashes for lookup. It also provides a standalone parse_csv_line function for one-off parsing needs and writes files safely using a temporary-file-and-rename strategy with optional backups and permissions, returning record counts and human-readable message lists instead of dying on I O errors. This module is a good fit for scripts and small applications that need dependable, configurable delimited-file I O without the weight of larger CSV libraries.

App::makefilepl2cpanfile is a small utility for converting a Perl project's Makefile.PL into a cpanfile by parsing the file text without evaluating it. It extracts runtime, build, test and configure prerequisites, understands both simple PREREQ_PM hashes and structured prereqs or META_MERGE blocks, preserves inline comments and relationships like recommends and suggests, and emits a properly structured CPAN Meta style prereqs block. You can merge an existing cpanfile develop section and optionally inject a default set of developer tools drawn from a per-user YAML config, and the module returns a ready-to-write cpanfile string. Because it uses regex-based parsing rather than running the Makefile.PL, it cannot detect dependencies that are produced only by conditional logic or by runtime code, but that tradeoff keeps the conversion safe and reliable for the many projects with static dependency lists.

Object::Proto::Sugar gives you a compact, Moo-like declarative syntax on top of the Object::Proto engine so you can declare attributes, inheritance, roles and method modifiers with keywords like has, extends, with, before, after and around while getting the speed and low overhead of Object::Proto's XS core. It supports rich attribute options such as read/write modes, type checks, defaults, builders, triggers, predicates, clearers, function-style accessors and weak or private refs, and it offers both positional attribute shorthand and role-aware requires. Type names and sugar shortcuts are opt-in at import time so you only pull in the helpers you need. The module is designed for high performance compared with Moo/Mouse and recent releases added per-class accessor prefixing via accessor_alias and a prv/private shortcut to declare accessors that are only callable from the owning package. If you want concise attribute-based OO with role composition and method modifiers but need minimal runtime cost, this module is a good fit.

Object::Proto provides a fast, feature-rich alternative to Perl's bless-based objects by storing objects as arrays and mapping named properties to fixed slot indices at compile time. It generates optimized accessors and supports both positional and named constructors while still blessing objects so isa and can behave normally. You get built-in type constraints, defaults, lazy builders, triggers, predicates, clearer/reader/writer variants, weak references, and modifiers like readonly or private, plus inheritance, multiple parents, prototype chains for delegation, cloning, locking and permanent freeze for immutability, and singleton support. Roles and method modifiers are available for composition and hooks, and you can import function-style accessors compiled to custom ops for maximum speed. XS modules can register C-level type checks and coercions for minimal overhead. Choose Object::Proto when you want compact, high-performance objects with declarative attributes and optional type safety or when prototype-style delegation and ultra-fast accessors matter in performance-sensitive Perl code.

CLI::Cmdline is a tiny, zero-dependency Perl command-line parser designed for simple scripts and utilities. It handles short and long options, aliases (using "|" in specs), bundled single-letter flags, repeatable switches that are counted, options that accept arguments either as a separate token or with "=value", automatic collection into arrays when you predefine an option as an arrayref, and recognizes "--" to stop option parsing. The parse() function updates a supplied %opt hash in place, strips processed options from @ARGV leaving only positional arguments, returns true on success and false on error, and restores @ARGV if parsing fails. If you need a lightweight, dependency-free alternative to heavier Getopt modules for straightforward command-line handling, this module is a good fit. Recent releases added exporting of parse() for convenience and small performance gains from precompiled regexes, while the latest patch adjusted tests and example shebangs.

File::Sticker is a Perl module for reading and writing standardized metadata on files and keeping a matching database in sync. It can extract metadata from files using multiple methods, add or remove fields including multi-value fields, overwrite all metadata for a file, and derive additional values via plugins. It also provides database operations such as batch updating files into the DB, querying records for a specific file, searching with a plus/minus tag syntax, listing faceted tags, and detecting missing or overlooked files so you can clean up obsolete entries. The module selects format-specific handlers or "scribes" as needed and includes simple debugging support, making it useful whenever you need consistent, scriptable management of file metadata alongside a searchable index.

DBIx::QuickDB makes it trivial to spin up disposable database servers for tests and development, supporting PostgreSQL, MySQL/MariaDB, SQLite and optional DuckDB so you can get a real DB instance without manual install or config. You can declare named database constants at compile time or build instances on the fly, then connect with DBI as you would any database, and the module accepts a flexible spec for autostart/autostop, bootstrap, cleanup, custom data directories, preferred drivers, SQL to load and whether the instance should be globally cached. Environment variables like QDB_TMPDIR and DB_VERBOSE control temp directory location and server output which is handy for CI and debugging, and features such as pooling, cloning and robust cleanup aim to make ephemeral instances reliable across platforms including Windows. Recent releases focus on reliability and platform quirks, notably changing MariaDB bootstrap to require a matching installer helper and to fail cleanly when helpers are missing, and fixing many startup, shutdown and Windows file-locking issues so test suites are less likely to leak or hang. If you need lightweight, repeatable real database instances for automated tests or local development this module is directly relevant.

Hyperman is a high-performance PSGI web server that combines a prefork supervisor with a per-worker event loop to run Plack apps efficiently. You start it with your PSGI app and a worker count and it can handle synchronous responses or async ones via Hyperman::Future so handlers can await timers or I/O without blocking the worker. It supports HTTP/2 (via nghttp2) and TLS with client-cert verification and SNI when built with the appropriate libraries, and it exposes simple timer and io_ready futures plus per-worker stats for introspection. A supervisor process manages worker lifecycles with zero-downtime reload and graceful shutdown, and the implementation is mostly XS/C for low-level performance. If you need extreme throughput for Perl web apps and want built-in async, HTTP/2, and TLS support, Hyperman is worth evaluating, but note that per-worker SO_REUSEPORT accepts scaling can behave differently on macOS so that option is off by default there.

Filename::KeyValue parses filenames that carry metadata as dash-separated key=value pairs at the end of the name and returns a structured result with the file extension, a prefix (the part before the first key), the raw kv segment, and a hash of keys to values. It understands multiple values separated by commas, supports URI-decoded values, and lets you control whether values are always returned as arrays or collapsed into comma strings via the array_value and decode_value options. The main routine parse_keyvalue_filename returns an enveloped response with an HTTP-like status code and payload so callers can detect errors cleanly. This small utility is used by the AssetView media-asset scheme and is handy when you need to extract embedded metadata from filenames without writing custom parsing code.

Fetch is a modern Perl HTTP client that gives you high-performance, asynchronous requests via Fetch::Future objects while also working synchronously when you call ->get because it will pump an event loop for you. Its performance hot path is implemented in vendored C and it speaks HTTP/1.1 and HTTP/2 over cleartext and TLS with connection pooling, redirect following, per-request timeouts, streaming bodies, a cookie jar, JSON helpers and native WebSockets. You can use it out of the box with its built-in standalone loop or plug it into existing async frameworks like IO::Async, AnyEvent or Hyperman so the same code can run as a simple blocking call or as thousands of concurrent requests. Requests resolve to Fetch::Response objects with status, headers and content and failures manifest as failed futures you can inspect. The 0.02 release fixes a small C-level bug in URL scheme handling.