CPANscan

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.

DBIx::QuickDB is a convenience library that quickly creates disposable database servers for development and testing so you can get a real PostgreSQL, MySQL/MariaDB or SQLite instance up and running with minimal fuss. You can declare named databases at compile time to get constant-like access or build them on the fly at runtime and call connect on the returned object, and the creation can be tuned with a simple spec to control autostart, autostop, bootstrapping, cleanup, directory location, driver choice, preloaded SQL and whether the instance is cached for reuse. It also exposes a driver check that reports whether a requested backend is usable and why not when it is not, and respects environment variables like QDB_TMPDIR for temp directories and DB_VERBOSE to show server output. The module is aimed at test suites and rapid prototyping where you want an isolated, real database without manual installation work, and recent releases have reduced noisy MySQL output, fixed MariaDB binary detection and added a resync method along with a few minor bug fixes.

App::prepare4release automates the routine work of getting a Perl distribution ready for release by scanning your distribution root and updating Makefile.PL, README, CI files, and packaging metadata so you can publish with less hassle. It reads prepare4release.json and infers missing values from your main module and Makefile.PL, injects a Makefile postamble that regenerates README.md via pod2github or pod2markdown and writes a small standalone maint/inject-readme-badges.pl to keep badges in sync without adding runtime dependencies, adds license and Perl-version badges, creates basic author tests under xt/author, and can create GitHub Actions or GitLab CI templates when requested. For CPAN publishing it will also ensure a LICENSE file, produce a MANIFEST.SKIP when needed, run perl Makefile.PL and make manifest, and it warns about legacy Test::More/Test::Most usage in tests. A recent change made the JSON file handling more robust by warning on invalid JSON rather than failing and added a new App::prepare4release::Deps component that statically scans lib/bin/maint/t (and optionally xt) for use/require lines and can optionally merge missing modules into PREREQ_PM and append requirements to cpanfile so dependency metadata can be synchronized automatically.

Data::Queue::Shared is a Linux-only, 64-bit Perl library that gives you very fast, bounded shared-memory queues for multiprocess communication, letting multiple producers and consumers exchange integers or byte strings without the overhead of the kernel message queues. It ships lock-free integer queues based on the Vyukov MPMC algorithm for high-throughput numeric job IDs and compact int32/int16 variants that trade range for density, and a mutex-protected string queue that stores variable-length messages in a circular arena with UTF-8 preservation and automatic stale-lock recovery. Queues can be file-backed, anonymous for fork-based sharing, or created with memfd for safe file-descriptor passing between processes, and the API supports nonblocking and blocking push/pop with timeouts, batch operations, eventfd integration for event-loop wakeups, and manual sync/unlink management. The module is tuned for performance and shows large throughput gains over popular Perl IPC modules while offering diagnostics and optional keyword-style calls for lower dispatch overhead. If you need very fast interprocess queues on Linux for worker pools, job dispatch, or message passing, this module is a strong choice, but it requires a 64-bit Perl on Linux.

Future::Uring is a lightweight Perl wrapper that exposes Linux io_uring operations as Future-based asynchronous functions, so you can perform high-performance, nonblocking file and socket I/O from Perl without wrestling with low-level ring management. It offers familiar high-level calls for opening files and sockets, creating and managing directories, renaming and unlinking, waiting for child processes, and creating timeouts, and it returns handle objects that let you read and write asynchronously while taking advantage of io_uring features like linked submissions, drain and timeout options. The module also provides helpers to submit and wait for events or to convert existing Perl handles into Future::Uring::Handle objects, making it a practical choice when you want io_uring performance with a simpler API. This is an early, experimental release so the API may change, but recent updates have added statx support, refined how the io_uring instance is managed, and added additional open flags.

Future::IO::Impl::Uring is a drop-in implementation of the Future::IO backend that runs on Linux io_uring via IO::Uring, so you can make Future::IO-powered nonblocking IO operations use the high-performance io_uring interface simply by loading the module. It exposes no extra API; you just use Future::IO as normal and this module supplies the implementation. It requires Linux kernel 6.7 or newer and will share its io_uring backend with Future::Uring when that module is present. Recent releases delay ring creation until first use and now rely on IO::Uring::Singleton to simplify memory management and enable safe ring reuse.

IO::Uring is a low-level Perl binding to Linux's io_uring that lets you schedule asynchronous I/O operations and receive completions via callbacks, reducing system-call overhead for high-throughput network and file workloads. It maps many familiar syscalls to methods that take submission flags and a completion callback, and it supports advanced features like multishot reads/accepts, pre-registered buffer groups, linked or drained submission chains, timeouts, and cancellation. You drive the ring from Perl with methods like submit and run_once, so this module is aimed at developers building servers, proxies, or other performance-sensitive code who are comfortable managing an event loop and working close to the OS. This is an early, experimental release and requires a recent Linux kernel, so expect the API and feature availability to evolve.

Crypt::OpenSSL3 is a modern Perl wrapper around OpenSSL 3 that lets Perl programs use the TLS, cryptography, and certificate features provided by OpenSSL. The distribution organizes functionality into focused modules for making SSL connections, handling asymmetric keys, symmetric ciphers, message digests, MACs, key derivation functions, and X.509 certificates while the top-level Crypt::OpenSSL3 module exposes error handling and build/configuration introspection so you can query OpenSSL version and build metadata from Perl. If you need direct access to OpenSSL 3 capabilities from Perl for tasks like TLS client or server connections, certificate parsing and validation, or general-purpose cryptographic operations, this package is a straightforward choice. The project is newly released and the latest update fixes various compilation issues for clang and C++ builds.

ExtUtils::ParseXS is a compiler that converts Perl XS source into the C glue code needed to build native Perl extensions so C functions can be called from Perl. You give it an .xs file and it emits a C file while consulting typemap files to translate between Perl values and C types, and it supports options such as C++ linkage, exception stubs, prototype generation, line-number directives for better diagnostics, runtime version checks, optimizations and custom typemap precedence. It offers an object oriented API and a legacy functional interface which is discouraged, and it can be configured to die or return errors instead of forcibly exiting the process. One maintainer notes uncertainty about the short "s" option, but otherwise this maintained tool is the standard way to turn XS into buildable C code when creating Perl extensions.

Net::CardDAVTalk is a compact Perl client for talking to CardDAV servers that was written to map CardDAV operations onto an older FastMail API and to serve as an example and test tool for the Cyrus IMAP Cassandane suite. It exposes simple methods to create, update and delete address books and contacts, to fetch single or multiple contacts and their properties, to perform multiget and sync operations using syncToken, and to move contacts between collections. It works with JSContact-style Perl hashrefs, will generate UIDs for new cards when needed, and returns data as Perl hashrefs and arrayrefs including etags and sync tokens. If you need a lightweight CardDAV toolkit for scripting or testing and do not require a full-featured, generic client, this module provides a straightforward, example-driven interface tailored to FastMail/Cyrus testing scenarios.

Net::CalDAVTalk is a Perl client library for CalDAV servers that gives you a simple, JSON-friendly way to discover and manipulate calendars and events. It builds on Net::DAVTalk and adds CalDAV and Cyrus namespaces, automatic discovery via /.well-known/caldav or SRV DNS, timezone caching and a pluggable logger. The module supports common tasks such as listing, creating, updating and deleting calendars, creating, updating, moving and deleting events, batch multi-get and href listings, free‑busy queries, vcalendar parsing and iCal export, and sync operations using CalDAV sync-tokens, returning useful values like hrefs, ETags and updated UIDs. It was developed at FastMail and is tuned to their earlier API and test suite, so it is especially useful for automation, testing and integrations that need programmatic CalDAV access.

Text::JSCalendar is a small Perl toolkit for translating calendar data between the iCalendar RFC 5545 format and the newer JSCalendar model, so you can convert vCalendar text into Perl event structures and back again. It offers convenience routines to parse an entire iCal file into events and to render one or more events as a vCalendar string, utilities to normalize events without mutating the originals, a comparison function to test event equality, and a cached timezone lookup using DateTime::TimeZone for better performance. This module is aimed at developers who need reliable interoperability between CalDAV/iCalendar and JSCalendar representations in Perl projects.

Crypt::SecretBuffer provides a secure container for sensitive byte strings so you can avoid accidental copies, accidental logging, or lingering plaintext in a long-running Perl process. It stores the secret in memory managed by XS code that wipes old buffers on reallocation and on destruction, and it offers safe ways to read and write the bytes without creating temporary Perl scalars. Common uses include reading a password from the console with echo disabled, feeding a secret directly into a child process via an as_pipe/write_async helper, and handing the raw bytes to C/XS functions with unmask_to or the module's C API so the secret is not copied into Perl's heap. The API also includes parsing helpers (Span objects), constant-time memcmp and scan options to reduce timing-attack risk, file load/save, and utilities for length-prefixed and various integer encodings. Recent releases improved console prompting behavior and made comparisons constant-time, and the module documents how to interoperate with callers that do not depend on Crypt::SecretBuffer. Note that this tool lowers the chance of accidental exposure but does not magically make a scripting language a perfect environment for long-lived secret management.

Test2::Harness is the engine that runs and manages test suites for the Test2 ecosystem, handling execution, TAP/Test2 event collection and aggregation so your test files can be run in parallel, retried, rerun, or under a persistent runner. It is meant to be used through the App::Yath command-line UI rather than directly, and it offers features you expect from a modern harness such as plugin hooks, resource management for shared or exclusive test resources, coverage and timing support, interactive and persistent modes, and facilities for rerunning failed or changed tests. The project has matured over years with many stability and usability improvements, and recent releases include AI-assisted bug fixes (carefully reviewed by the author) plus a new --resource-timeout option to better control resource waits. If you need a flexible, production-ready test harness that integrates tightly with Test2 and supports advanced workflows like persistent runners and resource-aware scheduling, Test2::Harness is likely relevant for you.

Eshu is a fast, XS-powered indentation fixer that rewrites leading whitespace for C, Perl, XS, XML, HTML, CSS, JavaScript and POD source files while leaving line content unchanged, making it easy to normalize code formatting across a project. It understands language-specific constructs that affect nesting and indentation, automatically detects file types by extension, offers options for tabs or spaces and indent width, and can operate on single files or whole directory trees via a command line tool or a vim plugin. The tool preserves verbatim regions like heredocs, template literals and script/style blocks, can produce diffs or run in CI check mode, and skips binary or oversized files to avoid accidental corruption. Recent releases fix a number of edge cases including correct handling of PROTOTYPES and the $# array-index operator and improve callback indentation logic and test coverage across all language engines.

Data::Buffer::Shared provides small, fixed-size typed buffers that live in file-backed shared memory so multiple processes can read and update data with very low latency, making it useful for interprocess counters, numeric arrays, and other compact shared state. It offers separate typed variants for integers, floats, and fixed-length strings and supports file-backed, anonymous, and memfd-backed mappings, with both keyword and method APIs. Numeric elements support lock-free atomic get/set and atomic counter operations such as incr, add, and compare-and-swap while bulk reads and writes use a seqlock and a futex-based read/write lock with stale-lock recovery for safe batch operations. Advanced features include atomic bitwise ops, batch atomic add, zero-copy mmap-aliased scalars, raw pointer access, fd passing, and eventfd notifications for signaling between processes. Note that the module is Linux-only, requires 64-bit Perl, and buffers are presized and do not grow, so plan capacity up front.

Data::Frame is an experimental Perl module that offers an R-like data frame built on PDL piddles so each column is a PDL array and numeric columns can carry PDL "BAD" missing values. You construct frames from arrays or hashes of columns and can name rows and columns, select or slice rows and columns, and use lvalue slices for in-place updates that follow PDL data flow. It includes common data wrangling features such as head and tail, row sampling, sort and unique, cbind/rbind style merge and append, split/grouping by a factor, column-wise transform with coderefs or mappings, and summary statistics with configurable percentiles. The module also provides conveniences like copying, renaming, checking column types, dropping rows with BAD values, and hooks for CSV I/O and tidy-style evaluation. If you work in Perl and need fast, column-oriented numeric and mixed-type table manipulation with PDL integration this is relevant, but be aware the author marks the library experimental so the API may still change.

Sidef is a modern scripting language engine you can embed in Perl to parse, compile, optimize and execute Sidef code from your Perl programs, or to compile Sidef into Perl for inspection or high-performance execution. It blends object oriented and functional idioms, offers native arbitrary precision integers, rationals, floats and complex numbers, supports multiple dispatch, pattern matching, lazy evaluation and a full class system, and gives direct access to CPAN modules so you can reuse Perl libraries without glue code. The Sidef module exposes a simple API for running one‑liners, REPL sessions, AST parsing and optimization, and for caching compiled output with an optional DBM-backed cache to speed repeated runs. To build and use it you need the GMP/MPFR/MPC C libraries for numeric support and optionally DB_File or GDBM_File for caching, and you should note the bundled cache is not thread safe and Unicode behavior follows Perl's implementation. If you want a Ruby/Raku-like language that runs on the Perl ecosystem and can be embedded, instrumented and compiled back to Perl, Sidef provides a polished, developer friendly toolset to do that.

CPANSA::DB packages the CPAN Security Advisory reports as a ready-to-use Perl data structure so your code can programmatically read the advisory database. It exposes a single method, db, which returns a hashref containing all advisories, and although it was created for CPAN::Audit any Perl program can use it. Each release also ships a JSON equivalent and includes verifiable artifacts such as GPG signatures and GitHub attestations so you can confirm the archive came from the official source. If you need a simple, authenticated way to consume CPAN security advisories in Perl, this module provides the data and the verification hooks.