CPANscan

SPVM::Resource::RE2 bundles the Google RE2 regular expression engine for use in SPVM native extensions by supplying the RE2 C++ sources and headers so you can call RE2 APIs directly from SPVM C++ code. It targets C++17 and documents the needed compiler and linker settings, including linking the C++ standard library and using -pthread, with extra static libraries recommended on Windows, so adding RE2 to an SPVM project is mostly a matter of enabling the resource in your build config. The package ships the RE2 2023-02-01 sources, is MIT licensed, and recent updates added a way to retrieve the version string and raised the SPVM minimum requirement to 0.990042.

Hustle::Table is a small Perl class for building fast, cached routing tables that map inputs to values using regex, code, exact, begin, end or numeric matchers. You add match/value entries in a few simple forms and then call prepare_dispatcher to produce an anonymous subroutine that tests inputs (including lists of inputs) against the table and returns any matching entries together with regex captures. The dispatcher uses an optional external cache for high performance and will return multiple matches per input while a default fallback entry is always available when nothing else matches. If you modify the table you must rebuild the dispatcher and manage cache eviction yourself. Note that recent releases standardize matchers so regular expressions are provided as strings and code matchers must be declared with type "code", and the implementation has received cache lookup and allocation optimizations to improve speed. This module is a good fit when you need a simple, efficient way to route or dispatch inputs in Perl without pulling in a larger framework.

Net::Async::NATS is an asynchronous Perl client for the NATS messaging system built on IO::Async that implements the NATS wire protocol over TCP and provides publish/subscribe, request/reply with auto-generated inboxes, wildcard and queue group subscriptions, automatic PING/PONG keepalive, reconnect with subscription replay, and server INFO/cluster discovery. It exposes simple async methods such as connect, publish, subscribe, request, unsubscribe, ping and disconnect and returns Futures so it plugs into IO::Async event loops, making it a good fit for event-driven services or microservices written in Perl that need lightweight low-latency messaging. Recent fixes improve connection robustness by ensuring reconnect attempts and their Futures are retained and cleaned up correctly to avoid hangs during reconnect.

SPVM::R brings core R language data structures and vectorized operations into the SPVM/Perl world so you can work with N-dimensional arrays, matrices and data frames with familiar R-like functions for arithmetic, reductions, trigonometry, ordering, sorting and slicing while handling NA values. It supports a wide set of element types including integer and floating types, signed long, complex numbers, fixed and variable-length strings and datetime values, and offers dedicated modules for array operations, matrix linear algebra and data frame manipulation. The API exposes R::NDArray and R::OP families plus R::DataFrame for creating, subsetting, sorting and filtering tabular data, and the project includes examples and a tutorial on GitHub to get you started. The package is actively maintained and has reached a stable milestone with comprehensive tests and documentation, and the most recent release parallelizes native and precompile builds for faster installation while updating the minimum SPVM requirement to 0.990154. If you need R-style numerical and tabular data handling inside SPVM or Perl codebases this module is likely relevant and saves you from reimplementing core array and data frame functionality.

Convert::VLQ is a small utility for encoding and decoding the base64 VLQ format used in browser source maps, so you can turn line and column numbers into the compact string form source maps use and parse those strings back into integers. It provides encode_vlq to convert a single number or an array reference of numbers into a concatenated VLQ base64 string, decode_vlq to convert a VLQ string back into an arrayref of integers or to return the first integer and the remaining string in list context, and low-level helpers int2vlqs and vlqs2int to convert between integers and signed VLQ values. The module is lightweight and purpose built for working with source map mappings, returns undef for undef input, and does not enforce the 32-bit integer limits that JavaScript imposes.

Git::Server is a drop-in replacement for a standard Git server that gives teams much finer control over server-side hooks, access rules and automated deployments than stock git-shell. It runs as the SSH command for incoming keys so each key can map to a REMOTE_USER and enforce per-user ACLs, restricted branches, file-level push restrictions, IP and email whitelists, webhook notifications and instant "git-deploy" style deployments. The distribution also provides helper tools and wrappers like git-client, git-deploy, git-verify and git-packer to simplify configuration, logging and safer automated workflows while keeping fewer dependencies than comparable hook frameworks. Recent releases focused on hardening and usability by honoring core.sshCommand and core.hooksPath, throttling abusive push notifications, adding read-only repo support, caching common ref lookups and improving deploy and verification behavior. If you manage a self-hosted Git service and need stronger policy enforcement, audit hooks or automated deployment integration, Git::Server is likely worth evaluating.

JSON::Create is a fast, configurable Perl encoder that converts Perl scalars, arrays and hashes into JSON. It offers a simple functional API (create_json and create_json_strict) plus an object-oriented interface to control formatting, indentation, key sorting and how odd types are handled via user callbacks for objects, unknown references and non-finite numbers. The module enforces UTF-8 input and always emits valid UTF-8 output while providing options to replace or downgrade bad UTF-8 and to toggle JavaScript-safe escapes and full Unicode escaping. It is implemented in XS for performance with a pure-Perl fallback, supports native boolean round trips, and includes convenience helpers such as write_json. If you need predictable, high-performance JSON output from Perl with hooks to customize serialization, JSON::Create is a good choice. The recent 0.36 release fixes an unsigned integers bug.

Data::HashMap::Shared implements file-backed, type-specialized hash maps in shared memory to enable fast, efficient multiprocess data sharing on Linux. It uses a futex-based read-write lock with a lock-free fast read path and provides lock-free atomic counters for increments and compare-and-swap on integer variants. Multiple typed variants cover integer and string keys and values, and features include optional LRU eviction, per-key TTLs, sharding across multiple files, an arena allocator for string storage, and both keyword and method APIs with batch operations and independent cursors. It also supplies atomic remove-and-return primitives useful for work queues, diagnostic stats, pre-reserve and unlink operations. Requirements and caveats are that it is Linux-only and requires 64-bit Perl, stale-lock recovery depends on a shared PID namespace so cross-container use is not supported, and data may need to be cleared after recovering from a writer crash for safety-critical applications. Overall it is a strong choice when you need a high-performance mmap-backed shared hash for cross-process caching, counters, or work queues on a single Linux host.

Object::Proto is a compact, high-performance Perl object system that stores objects as arrays and maps property names to numeric slots at compile time so getters and setters are extremely fast. It provides a rich attribute syntax with built-in and user-registered types, defaults, lazy builders, triggers, weak references, init_arg, reader/writer names, required and readonly modifiers, plus inheritance, prototype chains, roles, method modifiers, BUILD/DEMOLISH hooks, singletons, and mutability controls like lock and freeze. Accessors can be compiled into custom ops or imported as function-style calls for even more speed and objects are properly blessed so isa, can and ordinary package methods behave as expected. Recent releases fixed a Perl 5.36+ linker issue and changed clone() to perform deep clones and accept any reference, and the module now requires Perl 5.10 or newer. This module is a good fit when you want a full-featured, low-overhead attribute system for performance-sensitive Perl code.

Object::Proto::Sugar provides a Moo-like declarative syntax layer on top of Object::Proto so you can declare attributes with has, set up inheritance with extends, consume roles with with, declare required methods inside roles, and add before, after and around method modifiers using concise declarative forms. It exports type constants such as Str and ArrayRef and supports familiar attribute features like defaults and builders, lazy evaluation, coercion, triggers, predicates, clearers, named readers and writers, function-style accessors, init_arg aliases and weak references. The syntax compiles down to Object::Proto's XS-backed core for zero runtime overhead and benchmarks in the documentation show it is notably faster than Moo and Mouse while offering optional function-style accessors for maximum performance. Choose this module when you want the ergonomic, declarative API of Moo but need the speed and low overhead of Object::Proto. This is the initial public release.

Attean is a Perl framework for working with Semantic Web data that lets you parse, store, query and serialize RDF and SPARQL in a consistent way. It provides core building blocks such as memory-backed stores, quad models, iterators for streaming triples and quads, and SPARQL evaluation so you can load data, run queries and emit results. A pluggable lookup system finds parser, serializer and store implementations by name, filename extension or media type so you can extend functionality with AtteanX modules. It also includes helpers for HTTP content negotiation and producing Accept headers, and hooks to register custom SPARQL functions, functional forms, aggregates and datatype roles. If you need to process RDF data or build SPARQL-capable services in Perl, Attean gives a flexible, extensible foundation.

EV::Redis is a high-performance, non-blocking Redis client for Perl that ties the hiredis C library into the EV event loop so you can issue Redis commands from event-driven applications with minimal Perl overhead. It is a drop-in replacement for EV::Hiredis and adds practical features for production use such as automatic reconnection, flow control via a max_pending/waiting queue, connection and command timeouts, TCP options like keepalive and TCP_USER_TIMEOUT, and TLS and RESP3 support including server push callbacks. Commands may be issued with callbacks or run in a fire-and-forget mode for very high throughput, and AnyEvent users can use it seamlessly through EV. Note that EV::Redis treats all data as bytes and does not do UTF-8 encoding or decoding for you, and that callbacks can create reference cycles unless you clear them before destruction. The 0.08 release is a notable fork from EV::Hiredis renamed to EV::Redis, updates the bundled hiredis, and introduces reconnection, flow control, TLS, RESP3 and several memory-safety fixes.

BBS::Universal is a Perl module for running a text-mode bulletin board over TCP/IP that speaks multiple vintage and modern terminal encodings, including plain ASCII, Atari ATASCII, Commodore PETSCII, and ANSI, so you can host a networked, retro-style BBS with color, graphics characters, and cursor control where supported. It is aimed at hobbyists, retro-computing fans, and developers who want a configurable, terminal-oriented BBS experience that runs over the network rather than serial lines. The module includes SysOp features such as an interactive menu, file display and management, a clock and animated menu options, and ongoing improvements to ANSI, ATASCII, and PETSCII handling. Note that the operator’s terminal must support UTF-8 to get full graphics character support. The project is under the Artistic License 2.0 and is actively developed, with recent fixes addressing a sudden failure and continued enhancements to drivers and SysOp tools.

Crypt::PostgreSQL is a small utility module that creates PostgreSQL-compatible password hashes so you can set encrypted passwords for database users without relying on Postgres itself. It provides encrypt_md5(password, username) to produce the legacy MD5-style hash and encrypt_scram(password, [salt]) to produce SCRAM-SHA-256 hashes, with the optional salt argument intended mainly for testing. The returned strings are ready to use in SQL such as ALTER USER ... SET ENCRYPTION PASSWORD, which makes this handy for DBAs and automation scripts that provision or manage Postgres accounts. The latest release added a SECURITY.md and updated CPAN metadata to align with CPAN security practices, and the author asks that any security issues be reported privately to the maintainer.

XS::JIT is a lightweight runtime JIT compiler that lets Perl programs compile and load C/XS code on the fly, offering a simpler and faster alternative to Inline::C for cases where you generate C dynamically. It avoids heavy parsing and xsubpp, invokes the C compiler directly, caches compiled modules, and exposes a small C API so other XS modules can drive compilation without Perl stack overhead. You map Perl names to C functions and the module can generate wrapper-style SV* functions for convenience or alias to XS-native routines for best performance, and it provides helper macros for argument handling plus compatibility shims for Inline::C. Common tasks are handled by methods such as compile, generate_code and is_cached, and it can emit the include and linker flags or return a static library path for build systems. Recent work has focused on platform robustness and features, including macOS hardened runtime and Windows build fixes and options to pass extra compiler and linker flags so you can link against external libraries. If you need to embed or generate XS/C code at runtime for speed or flexibility, XS::JIT is worth a look.

Crypt::TimestampedData is a compact Perl library for reading, writing, and manipulating TimeStampedData (.TSD) files as specified by RFC 5544. It provides simple methods to decode and encode TSD blobs, extract embedded original content and RFC 3161 TimeStampToken(s), and build new .tsd files from a marked file plus timestamp tokens, and it ships with handy command line scripts for creating, inspecting, and extracting TSDs. The implementation is intentionally minimal and uses Convert::ASN1 while treating CMS structures and timestamp tokens as opaque DER blobs, so full CMS or timestamp verification should be handled by specialized libraries if you need it. The module is cross platform and requires Convert::ASN1. The recent 0.02 release added a SECURITY.md and CPAN metadata to align with coordinated vulnerability disclosure practices.

App::Licensecheck is the engine behind the licensecheck utility that scans source files to identify licensing and copyright statements. It can inspect either just the top lines or whole files and returns normalized license identifiers such as "GPL-2.0-or-later" along with extracted copyright text, which makes it useful for license audits, packaging checks, and automated CI scanning. The module is simple to call from Perl, exposes configuration like how many header lines to parse, and is distributed under the GNU Affero General Public License.

Heap::PQ is a fast, C-backed binary heap implementation for Perl that provides min and max priority queues with several interfaces to suit different needs: a convenient OO API, a functional API optimized with custom ops, a raw array API for maximum performance, and a numeric-only variant that stores native doubles. It offers the usual priority-queue operations like push, pop and peek, bulk insertion and heap construction in linear time, peek_n to view the top N elements without removing them, search and conditional delete, and custom comparator callbacks for sorting complex objects. The raw array primitives make it easy to turn an ordinary array into a heap and to implement patterns such as finding the k largest elements. Benchmarks supplied with the module show significant speed improvements over pure-Perl alternatives, particularly for the functional and NV variants. The OO API is implemented with XSUBs rather than compile-time ops so it is not as aggressively optimized as the functional and raw paths, but it provides a familiar object-oriented interface when you prefer it.

CPAN::MetaPackager provides a simple way to build and manage a local SQLite database of CPAN package metadata by converting the standard CPAN index file 02packages.details.txt.gz into cpan.metapackager.sqlite. It ships with a prebuilt data file and command scripts to recreate the database from a fresh index, which is useful for offline lookups or feeding downstream tools such as CPAN::MetaCurator that can read the database by default from /tmp. Creating the database from the full index can be time consuming on modest hardware, and version 1.01 adds timing output to the import process so you can see progress. The project is open source on GitHub and maintained by Ron Savage.

CPAN::MetaCurator provides tools to manage a local SQLite database named cpan.metacurator.sqlite that stores curated CPAN metadata and powers simple web views of that data. It helps import exported Perl.Wiki content such as JSON tiddlers and rebuild a hierarchical jsTree of your wiki for site navigation. The distribution also includes utilities to patch your site index, prepare and upload refreshed wiki pages, and convert change logs into machine-readable form. It is aimed at CPAN authors and site maintainers who want an easy way to maintain and publish a curated, browsable copy of CPAN metadata locally or on a website. The module is maintained by Ron Savage, the source is on GitHub at https://github.com/ronsavage/CPAN-MetaCurator, and it is released under the Perl 5 license.

Module::Metadata extracts useful information from Perl module files (.pm) so tools and authors can inspect packages without fully loading them. It uses mostly static analysis but will evaluate $VERSION assignments to report accurate versions. You can build an object from a filename, filehandle, or module name and optionally collect and decode POD sections. The module can find modules in @INC, list packages inside a file, check if a package is PAUSE indexable, and produce CPAN META "provides" data or a directory-to-package version map for packaging and release workflows. It also handles common byte order marks and encoding declarations making it practical for use in build systems, CPAN tooling, and other automation that needs reliable module metadata.

SPVM is a statically typed language with Perl-like syntax that aims to give you the safety and performance of compiled code while keeping familiar Perl idioms and easy integration with the Perl world. It supports ahead-of-time and just-in-time compilation, native threads and lightweight goroutine-like concurrency, static analysis and type inference, direct C and C++ bindings, and a Perl-side calling API so you can invoke SPVM classes from Perl and pack compiled SPVM programs as standalone executables with the spvmcc tool. The project also provides a growing standard library and tooling for building, testing and distributing native and precompiled classes, so it is useful when you need high-performance components, native library wrappers, or tighter control over binary deployment from Perl projects. Be aware that SPVM has not reached 1.0 yet and its maintainers do not guarantee long-term backward compatibility. A notable recent improvement is a major revamp of the build system to a parallel, SHA1-hashed pipeline that speeds up native and precompiled class compilation, adds a JSON build_file option to avoid Windows command-line limits, and introduces parallel make support and unified make rules for safer, much faster builds.

SQL::SimpleOps is a Perl helper that builds and executes common SQL commands for DBI-backed engines so you can issue inserts, updates, deletes and selects without hand-crafting SQL strings. It supports MySQL, MariaDB, Postgres and SQLite3 and adapts statement syntax per engine while leaving data types unchanged, so you can switch databases without recoding SQL construction. The module offers convenient features for real applications like alias maps for tables and columns, multiple buffer return styles (array, hash, scalar or callback), cursor-based paging, optional SQL logging to disk or syslog, and simple transaction control and commit options. It is a command builder and executor rather than a full SQL parser, and it enforces safety for dangerous operations by requiring explicit force flags for full-table updates or deletes. Use SQL::SimpleOps when you want a lightweight, DBI-friendly layer to reduce boilerplate SQL assembly and handle common CRUD and paging patterns across different engines.

Exporter is the standard Perl utility that implements a default import method so modules can export functions and constants into a caller's namespace without writing their own import routine. A module declares what it can export using @EXPORT for default exports and @EXPORT_OK for optional exports, and callers pull in names with use Module qw(...). Exporter supports convenient features such as named export tags, pattern-based selection, an export_fail hook for handling unavailable symbols, and export_to_level for unusual calling situations, and it will treat a bare numeric import as a version check via VERSION. The documentation stresses modern best practices like preferring @EXPORT_OK over default exports, never exporting method names or variables, and shows how to import Exporter’s import function instead of inheriting the whole package. Recent maintenance updates clarified the non-inheriting usage and made the module strict and warnings compliant while keeping its lightweight, widely compatible behavior.

Net::Daemon is a lightweight abstract base class for building portable TCP or Unix-socket server daemons in Perl, providing the common plumbing so you can subclass, implement Accept and Run and focus on the protocol logic rather than socket, logging and lifecycle details. It bundles command line parsing and config file support, host-based access control, safe startup features like chroot, UID/GID dropping and pidfile handling, multiple concurrency modes (Perl ithreads, fork, preforked children or single-connection), a Clone mechanism for per-connection objects and a post_clone hook for per-connection initialization. The module also centralizes logging through Sys::Syslog or Win32 event logging and exposes handy helpers for debug and fatal errors. Recent maintenance tightened up threading and forking behavior, fixed Unix socket client auth and logfile handling, added a --listen option for backlog control, and fixed zombie and thread-leak issues, so it is better suited to modern Perls. Note that historical quirks with Sys::Syslog on some platforms have been documented and may require minor workarounds on affected systems.

Tree::MultiNode provides a simple object-oriented tree structure for Perl where each node holds a key, a value, and an ordered list of children, and all tree access and manipulation is done via lightweight Handle objects so you can have multiple cursors into the same tree without copying. It is intended for modeling hierarchical data such as nested records or parent/child relationships and supplies straightforward operations to add, insert, remove, and navigate nodes with methods like add_child, first, next, prev, down, and up while preserving child order. The API also exposes traversal helpers and convenience accessors for child keys and values, making it easy to walk and process a tree. This is a mature, actively maintained module and recent releases fixed several crashes, corrected cloning bugs that could cause shared child mutations, eliminated circular-reference memory leaks by using weak parent references, and added methods such as num_children and child_values plus improved test coverage and modernized packaging. If you need a stable, easy-to-use tree structure in Perl to represent hierarchical relationships, Tree::MultiNode is likely a good fit.

Net::ACME2 is a Perl client library that implements the ACME protocol (RFC 8555) so you can programmatically create and manage TLS certificates from CAs like Let’s Encrypt. It provides high-level operations for creating and updating accounts, placing and finalizing orders, completing http-01, dns-01 and tls-alpn-01 challenges, fetching certificate chains and revoking certificates. The module supports RSA and ECDSA keys, account key rollover, external account binding when required by a CA, and comprehensive X::Tiny-based exception handling. It is written mostly in pure Perl with CryptX and Crypt::Perl as cryptographic backends and uses the host system TLS support for network I/O, and it can run synchronously or in an experimental asynchronous mode via a promise-based user agent. The distribution includes examples and CA-specific helpers such as Net::ACME2::LetsEncrypt to get you started.

CGI::Info is a Perl helper for CGI scripts that gathers environment details and request data so you do not hard code paths or server info, and it makes development easier by behaving sensibly when a script is run outside a web server. It offers methods to get script name, script path, document root and temporary directories, to detect client type such as mobile, tablet, search engine or bot, and to read cookies and POST or multipart parameters while supporting file uploads with a configurable maximum size. Its params handling supports validation rules expressed as regexes, Params::Validate::Strict schemas or custom callbacks, and it includes a simple web application firewall that blocks common SQL, XSS and directory traversal patterns as an extra protection layer rather than a full security solution. The module is configurable at runtime via constructor options, config files or environment variables, supports pluggable logging and caching, and provides utilities like as_string, status and message reporting for debugging and caching keys. The recent 1.12 release fixed as_string returning undef, hardened WAF handling including NUL byte fixes and specific attack patterns, made the default max upload size runtime configurable, and added extensive unit, integration and edge tests to improve robustness.

IPC::Manager is a lightweight framework for message-based interprocess communication on a single machine that makes it easy to send structured messages between local processes using a variety of transport backends and serializers. You create or spawn a data store, share the small connection string it returns, and any process can connect, send and receive IPC::Manager::Message objects; stores can be temporary and auto-removed or persistent for long-lived services. The module ships with multiple client protocols so you can choose filesystem pipes, atomic files, Unix sockets, databases or shared memory as the message carrier, and you can swap serializers (JSON is the default) to suit your payloads. It also includes helpers for forking named services and workers so you can build nested service processes that communicate over the same bus. Recent work reintegrated DBI and UnixSocket clients, added JSONFile and SharedMemory transports, introduced exec-services, and fixed several DBI/UnixSocket bugs while adding more tests and documentation. If you need a simple, pluggable way to pass structured messages between processes on one host, IPC::Manager is a practical choice.

Modern::OpenAPI::Generator is a code generator that turns OpenAPI 3.x specs into ready-to-run Mojolicious clients and servers, model classes, docs and tests. It can emit synchronous and asynchronous client modules, shared Moo-based model classes from components/schemas, server controllers wired to Mojolicious::Plugin::OpenAPI, optional Swagger UI for in-app API exploration, and simple auth helper plugins, and it can also produce local-test stubs that return mock response data so you can exercise the API without implementing handlers. Generated servers validate incoming requests via the OpenAPI plugin and you can enable schema validation of outgoing and incoming messages for stronger correctness checks. Use the provided oapi-perl-gen command line tool or call the generator from Perl to produce an installable output tree and example README, docs and smoke tests. The recent release improves the CLI help by delegating to a dedicated CLI class and using Pod::Usage so help and usage messages are clearer.