CPANscan

Module::CheckVersion is a lightweight utility for checking whether an installed Perl module is up to date by consulting CPAN (via MetaCPAN) or other repository authorities. Its primary function, check_module_version, attempts to load a module, read its $VERSION and query the configured authority, then returns an enveloped result with an HTTP-like status code, a reason string and a payload that typically includes latest_version, installed_version and an is_latest_version flag so you can script or display version checks easily. The module is exportable and the distribution also provides a check-module-version command-line tool. It can handle non-CPAN modules if those modules provide an $AUTHORITY and you implement the corresponding Module::CheckVersion::<scheme> handler. The recent 0.090 release adds support for the darkpan authority scheme and the project has been kept up to date with MetaCPAN API changes.

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.

EV::Memcached is a high-performance asynchronous memcached client for Perl that plugs into the EV event loop and implements the memcached binary protocol in pure XS so no external C library is required. It is designed for low-latency, high-throughput workloads and offers pipelining, automatic reconnection, flow control, multi-get optimizations, fire-and-forget commands for maximum throughput, TCP and Unix socket support, SASL PLAIN authentication, and connect and command timeouts. The module treats all data as raw bytes so you must encode or decode UTF-8 yourself. It also works transparently with AnyEvent when EV is used as the backend. This initial release delivers the full command set including mget/mgets and SETQ/FLUSHQ along with reconnection and timeout controls making it a good choice when you need a nonblocking, efficient memcached client in Perl.

PDF::API2::Resource::XObject::Image::Imager makes it easy to embed Imager image objects into PDF::API2 documents so you can read images with Imager and drop them straight into a PDF page. You call $pdf->imager($img) to get an image XObject ready to be placed on pages, and the module leverages Imager to handle file formats rather than reimplementing PNG or TIFF parsing. Paletted images are converted to RGB and greyscale images are kept as-is, but 16-bit or floating point images are not supported and must be converted to 8-bit RGB first, and if you need to remove transparency you should strip the alpha channel before importing. Note that output currently uses simple FlatDecode compression, so for smaller files you may want to run the generated PDF through GhostScript (ps2pdf) as a poststep. The release includes only a small maintenance cleanup of unused code.

Bio::EnsEMBL is the Perl namespace for the Ensembl Core API that lets you programmatically connect to and query Ensembl genomic databases. It provides a Registry entry point to load database connections and retrieve adaptors for species and data types so you can fetch genomic slices, genes, transcripts, variation and other annotations by stable ID or coordinates. The module is aimed at bioinformaticians building scripts and pipelines who need reliable, scripted access to Ensembl data from Perl and it is mature, actively maintained and released under the Apache 2.0 license. The codebase is kept up to date with Ensembl releases and the current stable version targets Ensembl 114 for compatibility with the latest database schema.

DBD::DuckDB is a DBI driver that lets Perl programs use DuckDB, the fast embeddable analytical SQL engine, from a familiar DBI interface. It opens DuckDB databases stored in a file or a temporary in-memory instance, supports the usual DBI methods for preparing and executing statements, transactions, metadata queries, and offers DuckDB-specific helpers such as a high-performance appender for bulk loading and x_duckdb_read_csv/json/xlsx helpers for ingesting common data formats. You do need the native DuckDB C library installed, but the module works with an automatic installer via Alien::DuckDB or with a manually installed shared library. The driver understands DuckDB’s complex types like arrays, structs, maps and a wide range of scalar types, and exposes extra functions to access the underlying DuckDB C API. Recent releases expanded type support and bindings and improved low-level access: version 0.16 exports the full DuckDB C API, improves ARRAY and STRUCT bind handling, adds ENUM and BIT types and better DECIMAL support, and introduces a DUCKDB_NO_ALIEN environment flag to opt out of Alien::DuckDB. If you need to run fast analytical SQL from Perl against local or in-memory datasets, this module is likely relevant.

Math::MPFI is a thin Perl wrapper around the MPFI C library that gives you arbitrary‑precision interval arithmetic so you can represent numbers as rigorous intervals and track rounding and error bounds during computations. It exposes MPFI features from precision control and interval construction to basic arithmetic, transcendental and special functions, comparisons, set operations, random sampling, and input/output, and it supports convenient operator overloading so Perl expressions work much like normal numeric code. Because it wraps the native libraries it requires GMP, MPFR and MPFI to be installed (GMP first, then MPFR, then MPFI) and mirrors MPFI behavior such as returning unbounded intervals when dividing by intervals that contain zero and leaving handling of empty intervals to the caller. If you need validated numerics, reliable error envelopes, or high‑precision interval methods for scientific or numerical code, this module is directly relevant; be aware that it is essentially a direct binding to the underlying library and that some overloads such as the assignment overload have caveats noted in the documentation.

Chandra gives Perl developers a simple way to build cross‑platform desktop apps using web technologies by binding to the webview‑c library, letting you open a native window that hosts HTML/CSS/JS, run or manually control the event loop, execute JavaScript and receive JS→Perl callbacks. It targets macOS, Linux (WebKitGTK) and Windows and includes higher‑level helpers and companion modules for app structure, DOM-like element building, IPC sockets, system tray icons, native notifications and JS binding examples so you can quickly prototype interactive UIs from Perl. The project is experimental and marked alpha, but is actively developed; recent work ported core methods to XS for performance and added Chandra::Shortcut to handle keyboard shortcuts and global hotkeys.

Net::BART is a Perl library for fast IP prefix storage and lookup that supports both IPv4 and IPv6. It lets you insert prefixes with associated values, delete them, perform longest-prefix-match lookups, do exact-match retrievals, check whether an address is contained by any prefix, and walk all entries. Internally it uses a multibit trie with fixed 8-bit strides inspired by Knuth's ART to keep lookups quick and memory efficient, but you do not need to know the internals to use it. The distribution includes a pure-Perl implementation and an optional XS/C variant for maximum performance, making this module a good fit for routing, IP classification, firewall rules, or any task that needs fast prefix-based address mapping.

SPVM::Thread is a minimal, easy-to-use wrapper that brings native OS threads to SPVM by binding to C++ std::thread. It lets you spawn a thread with a Callback, wait for it to finish with join, and obtain its identifier via get_id, so you can run work in true parallel threads rather than cooperatively scheduled tasks. The API is intentionally small and straightforward, making it a good choice when you need to offload computation, perform background processing, or integrate with C++ libraries that expect native threads.

SPVM::Time::Piece provides a simple Time::Piece class for SPVM programs so you can create, inspect, format and manipulate dates and times in a familiar, object oriented way. You can build objects from epoch seconds as localtime or gmtime, parse timestamps with strptime, read individual components like year, month, day, hour and weekday, and produce formatted output with strftime, cdate, ymd and ISO datetime helpers. It also supports common date arithmetic and utilities such as add, subtract, add_months, add_years, week numbers, Julian and modified Julian day calculations, timezone offset, truncation to units and object comparison and cloning. The module aims to mirror the convenience of Perl's Time::Piece for SPVM users and has been kept current with recent SPVM releases; an option to allow negative epoch values was added in a prior release. The code is MIT licensed and maintained by Yuki Kimoto.

SPVM::MIME::Base64 is a compact SPVM port of the familiar MIME::Base64 functionality that makes it easy to encode and decode Base64 data in SPVM programs. It exposes simple class methods for encoding and decoding strings, where encode_base64 accepts an optional end-of-line string to control wrapping and by default breaks output into 76-character lines, and decode_base64 silently ignores non-base64 characters and stops at padding. For performance-sensitive code you can also ask for the encoded or decoded length without performing the conversion using encoded_base64_length and decoded_base64_length. The routines raise an exception if given an undefined input, the module is maintained on GitHub, and it is released under the MIT license.

SPVM::Digest::MD5 is an SPVM-native port of Perl's Digest::MD5 that provides MD5 hashing both as simple one-shot functions and as an object-oriented incremental interface. You can use Digest::MD5->md5 or md5_hex to compute a binary or hex digest of a single string, or create a Digest::MD5 object with new, feed data with add, and retrieve the result with digest or hexdigest. The add method requires defined input and does not return the invocant so chaining is not supported. The digest method returns a 16-byte binary string and hexdigest returns a 32-character lowercase hexadecimal string. The distribution is MIT-licensed and actively maintained with recent internal cleanups and updates to require newer SPVM releases.

SPVM::Resource::Zlib is a resource pack that bundles the zlib compression library (v1.3.1) for use in SPVM projects, making zlib's C headers and source files available so you can call standard compression functions such as gzopen, gzread and gzwrite from SPVM C code. You enable it in your SPVM::Builder::Config with use_resource('Resource::Zlib') and then include <zlib.h> in your C sources; the package supplies the necessary headers, C99 source files and common compiler flags for large file support. It mirrors the upstream zlib project, is distributed under the MIT license, and is useful whenever you need proven compression and decompression routines inside an SPVM module.

SPVM::Resource::Eigen packages the header-only Eigen C++ linear algebra library (version 3.4.0) as an SPVM resource so you can easily compile native C++ extensions that use Eigen. Add it to your build config with $config->use_resource('Resource::Eigen') and then include Eigen headers such as Eigen/Core or Eigen/Dense in your SPVM native C++ source compiled for C++17. The module copies the Eigen include files into the SPVM resource tree and exposes the common Eigen modules for dense and sparse linear algebra, decompositions and solvers, so you can leverage Eigen's matrix and numerical routines from SPVM code without manually managing Eigen headers. The resource mirrors the upstream Eigen project and is distributed under the MIT license.

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::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.