CPANscan

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.

Preproc::Tiny is a tiny, dependency-free Perl preprocessor for generating source files from templates using straight Perl code. You write templates with a .pp extension and plain text is copied by default while lines starting with @@ are treated as Perl and executed, and you can embed multi-line Perl with [@ ... @] blocks or use [@> ... @] to append to the global $OUT buffer and -@] to suppress the trailing newline. It ships as a single pp.pl executable but also provides pp_files for file-based processing and pp_text to process template strings from your own scripts. This module is ideal if you need the full expressiveness of Perl inside templates rather than a limited templating mini-language, it runs on older Perls (5.10+), and recent updates added the pp_text export and improved error reporting to show the Perl code when a template triggers a compile error.

Data::IconText is a compact Perl module for managing single-character "icon" text symbols and mapping common concepts to a single visible character. You create an icon object from a Unicode code point, a raw character, a country flag code, a media type or subtype, a few predefined special kinds, or by looking up related objects such as file, tag or identifier objects, and you can retrieve the result as a Perl string or as its numeric Unicode value. The module integrates with Data::Identifier so lookups can use attached subobjects and existing identifier data, and it offers a configurable fallback behavior with an option to suppress defaults. The recent 0.06 release improves integration by implementing several Data::Identifier interfaces and adds a mark() method to apply an icon text to other userdata objects, making this useful for UIs, file managers, tag systems and any code that needs consistent single-character icons.

StreamFinder is a Perl library that takes a web URL for a radio station, podcast episode, or online video and returns the actual playable stream URL or playlist together with metadata like title, artist, genre, station ID and cover or banner images so you can play content in your preferred media player instead of in a browser. It selects site-specific handlers for many services such as YouTube, Vimeo, Apple Podcasts, TuneIn and others, can fetch icon or image binary data, supports options for secure-only streams, HLS bitrate limits, logging and debugging, and reads per-site configuration files. The module is intended to be embedded in other Perl applications rather than run as a standalone program and is extensible by adding subpackages for new sites. Some sites rely on external helpers like yt-dlp and SoundCloud support is noted as deprecated because of cookie and tracker changes, so check dependencies before use.

LaTeX::Replicase is a compact Perl template engine for programmatically filling real TeX and LaTeX documents by replacing simple inline tags like %%%V:, %%%VAR:, and %%%ADD: with values from your Perl data structures. It is designed for creating configurable PDFs and tables by mapping scalars, arrays, hashes and nested array/hash table structures into template regions, and it deliberately keeps logic in your Perl data rather than in the LaTeX source. The module includes helpers to escape TeX special characters and to insert TeX glue for safer line breaking, supports a pipeline of processing actions, and offers options for UTF-8, conditional omission of undefined values, silence or debug output, and writing results to a file or STDOUT. Note the practical limitations documented by the author: it targets Perl 5.10 or newer, file and directory names must not contain spaces, tag names should stick to alphanumeric and underscore characters, and only the supported data shapes are handled. If you need a minimal, LaTeX-aware filler that keeps LaTeX templates intact while driving content from Perl, Replicase is a good fit.

WebDyne is the core runtime and rendering engine for the WebDyne framework that turns ".psp" pages with embedded Perl into HTML, either inside web servers like Apache/mod_perl, PSGI, or PAGI or from standalone scripts for tooling and offline generation. It exposes a handler method for normal server request lifecycles and convenience functions html() and html_sr() you can import to render templates to strings, scalar references, or directly to a filehandle, with options for parameters, custom handlers, and prebuilt request objects. The module supports compile-time parsing and caching, chained handler modules, filters, and familiar CGI-style parameter access, so it is useful when you want a PSP-based templating system integrated into Perl web apps or a simple command-line renderer such as the included wdrender. Full usage details and examples are available in the source tree and on the project GitHub page.

Dist::Zilla::App::Command::cover is a Dist::Zilla plugin that adds a "cover" command to generate test coverage reports for your Perl distribution using Devel::Cover. It runs only after your normal tests pass and deliberately ignores author and release tests so those checks do not skew your coverage numbers. You can pass extra arguments to the underlying cover tool and direct output to a chosen directory. The module is available on CPAN and the development source is hosted on GitHub. Recent updates include a new maintainer, documentation fixes, and a switch to loading dependencies at runtime to reduce upfront loading.

Net::Connection::ncnetstat is the Perl backend used by ncnetstat to produce a colorized, enhanced netstat-style display for programs and scripts. It gathers connection information (using lsof or sockstat depending on the platform), formats it into a table, and exposes options to show or hide process commands, use full command lines, suppress PID and user columns, apply match filters via Net::Connection::Match, and control sorting via Net::Connection::Sorter; you instantiate the object with the desired options and call run to get the formatted output string. The 0.8.0 release stopped attempting to sort by default. If you want scriptable, programmatic network-connection listings with filtering and nicer formatting this module is a good match, though the author notes future work to add more collection methods and configurable colors and column ordering.

Net::Connection::Linux_ss is a small utility that builds Net::Connection objects by parsing the output of the Linux ss command, typically running ss -p4an and ss -p6an to enumerate IPv4 and IPv6 sockets, or accepting those outputs as input strings for non‑Linux environments. It can optionally resolve port names, reverse DNS PTRs, and user names, and can enrich results with process details from Proc::ProcessTable and /proc so you get more complete information about owning processes, CPU and memory usage, and start times. The module returns one Net::Connection object for each process listed against a socket, matching lsof behavior so shared sockets may appear multiple times, and it skips sockets with no associated process by default to avoid undefined PIDs. Use this when you need a programmatic, Perl-native inventory of active network connections and the processes that own them on Linux.

Net::Connection::FreeBSD_sockstat converts the output of FreeBSD's "sockstat -46s" into Net::Connection objects so you can programmatically examine active TCP and UDP sockets. It offers simple flags to control whether port names and PTRs are resolved, whether to enrich entries from the process table, whether to skip zombie-style placeholder lines, and it can parse a supplied string instead of running sockstat for testing or non-FreeBSD use. The module is FreeBSD-focused and will die if you try to invoke sockstat on another OS unless you pass a string to parse. The most recent release fixed a missing dependency by adding Proc::ProcessTable.

Net::Connection::lsof is a small utility that runs the system lsof command and converts active TCP and UDP socket listings into Perl Net::Connection objects, making it easy to programmatically inspect local network connections. Call lsof_to_nc_objects to receive an array of Net::Connection objects and optionally pass a hash reference to control whether port names, reverse DNS PTRs, UID-to-username resolution, and extra process information are resolved or skipped. All those resolutions are enabled by default. The module shells out to lsof so lsof must be available on the host and the call will die if lsof exits with a nonzero status. Use this module when you want a quick, structured snapshot of system network sockets inside a Perl script.

Net::Connection::Sort is a lightweight Perl helper that sorts arrays of Net::Connection objects by common connection attributes, making it easier to present or analyze lists of network connections. You create a sorter with new by specifying a sort type and an optional invert flag, then call sorter with an array reference to receive the sorted objects. The module offers sorts for hosts, ports, protocol, process id, connection state, user id or name and an unsorted pass through, and it validates the requested type so only the documented options are allowed. The recent 0.2.0 release fixes a bug so the invert option is actually honored, closes a potential code injection vector in sort type selection, improves port and host sorting including handling of IPv6 zone ids, and requires Net::Connection 0.2.0 or newer. If you write tools that inspect or display connection tables this module saves you from rolling your own sorting logic.

Net::Connection::Match is a helper for filtering Net::Connection objects by running a configurable stack of checks and returning a simple boolean match result. You create it with a list of checks, each named after a Net::Connection::Match::* test and optionally inverted, and then call match with a Net::Connection instance to see if it passes the tests; if you supply no checks it defaults to an All test that always matches. Common checks cover ports, protocols, PTR lookups, CPU and memory usage and other connection attributes, so this module is useful when building monitoring, auditing or connection-handling tools that need to select sockets or processes by those properties. Errors from checks are reported via Error::Helper and recent updates improve cross-platform memory detection on BSDs, tighten argument validation, and change match behavior so a failing check raises an error instead of silently acting as a non-match.

Google::Auth is a small Perl library that handles Application Default Credentials and project ID detection so your Perl programs can authenticate to Google Cloud services without manual token handling. It provides an easy object interface and a default($scopes, $options) method that returns the appropriate credentials for the current environment, which is handy for local development, CI pipelines, or cloud-hosted services that rely on standard Google credential sources. The module is maintained by Google, is part of the google-auth-library-perl family, and is distributed under the Apache 2.0 license with issue tracking on GitHub and CPAN.

BATsh is a pure‑Perl bilingual shell that lets you write and run scripts mixing Windows batch (cmd.exe) and POSIX shell (bash/sh) syntax in the same file, with automatic line‑by‑line mode switching and a shared variable store so values set in one mode are immediately visible in the other. It implements most common cmd and sh builtins, pipelines, redirection, functions, arrays, command substitution, traps, interactive input, a REPL, inline source execution, and proper exit status propagation, and it runs entirely inside Perl so no external cmd or bash is required. The module includes encoding support and auto-detects CP932/Shift_JIS for Japanese Windows scripts, returns the script exit code for use in programs, and installs a command‑line wrapper for direct invocation. Not everything is reimplemented though, so nonbuiltins are invoked as external programs and therefore depend on the host OS, a few niche cmd features and some shell job control behaviors are limited or unimplemented, and you need Perl 5.005_03 or later.

Data::Displaycolour is a small Perl helper for assigning consistent display colours to arbitrary subjects such as usernames, real names, emails, free text or objects, making it easy for applications to pick a reproducible RGB or named colour for things that need visual identity. You create an instance with the subject or an explicit colour and the module will return an origin, abstract or specific colour or a concrete "#rrggbb" RGB value, with support for selectable palettes and language-aware lookups via the Data::Identifier ecosystem. It is useful when you want deterministic, human-friendly colours for people, items or messages without hand-picking values, and it can also list known palettes and colours so you can discover what it will choose. The package is still marked experimental in parts, notably palette matching, explicit import options and the new mark/register features introduced in v0.06 that let you register colours and tag objects for later retrieval, so expect refinements in future releases.

Data::Entropy provides a simple, globally accessible way to nominate an entropy source so algorithms that need randomness can obtain it without threading source objects through every call. It exposes entropy_source to read the current source and with_entropy_source to temporarily select a different source for the dynamic scope of a code block, which makes it convenient when a single entropy source is used across a program. The module ships with a reasonable default (an AES counter-mode generator seeded from a secure RNG) but it is now deprecated, and for most uses especially cryptography you should prefer modern alternatives such as Crypt::URandom, Crypt::SysRandom or Crypt::PRNG. Recent updates focused on security by seeding the default generator from Crypt::URandom and switching networked random-number services to HTTPS.

Test::RedisServer makes it easy to spawn a real redis-server for integration tests so your code can exercise a live Redis instance without manual setup. It starts a temporary server by default, accepts redis.conf options as a simple Perl hash, and returns a connect_info blob you can feed directly to the Redis client module. You can disable auto-start and use start, exec or stop to integrate with Test::TCP or other test harnesses, and the object cleans up the server and temp files on destruction while also exposing pid and wait_exit for finer control. The module is maintained to work with modern Redis and Perl releases and recent updates fixed tmpdir handling and a compatibility issue with newer Perl Time::HiRes behavior while improving tests and CI. If your tests need a disposable, configurable Redis process rather than a mock, this module is a straightforward choice, but note it requires the redis-server binary to be present on the test system.

Devel::MAT::Dumper is a small utility module that writes a snapshot of a running Perl process to disk so you can inspect its heap later with Devel::MAT::Dumpfile and related tools. It provides non-exported functions to write a PMAT-format heap dump to a file or filehandle and can be configured at import time to automatically dump on die, warn, END, or on receipt of signals (including an unsafe SIGABRT handler to capture native/XS context). You can control the output filename (with an NNN token for unique numbering), the maximum string length to capture, and whether the file is opened eagerly. The module is useful for diagnosing memory leaks, crashes, and mysterious runtime state on production or remote systems where analysis tools may not be installed. It was split out from the main Devel::MAT distribution so the dumper can be deployed independently. Recent updates add support for Perl internals changes such as Magic v2 from Perl 5.45.2 and related bug fixes to stay compatible with newer Perls.