CPANscan

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.

Perl::PrereqScanner::NotQuiteLite is a lightweight scanner that inspects Perl source to discover the modules and language features a project needs, classifying them as hard requirements, recommendations, suggestions found inside eval, or modules explicitly excluded with no. It is configurable with a set of parsers and accepts project or installed parser plugins so you can extend detection for nonstandard loaders and keywords, and it can scan files or strings and returns a Context object listing requires, recommends, suggests and noes. It recognizes conditionally loaded modules and some modern Perl features such as say and signatures to help determine a minimum perl version, and it aims to be faster than PPI-based scanners while remaining pure Perl though not as fast as an XS lexer based scanner. Options let you enable parsing of eval blocks, treat block-loaded modules as recommends, ignore paths, and dedupe modules that belong to the same distribution, making it useful when generating cpanfile or auditing dependencies for packaging and CI. The project is mature and actively maintained and the latest release adds support for builtin and experimental class features as well as Feature::Compat::Class, improving detection for newer language constructs.

String::FillCharTemplate provides a tiny, focused utility to populate placeholder characters in a template with characters taken sequentially from an input string. You call fill_char_template(template, string) and each placeholder in the template is replaced by the next character from the input, with any remaining slots padded with spaces so the template layout is preserved. It is ideal for simple tasks like inserting digits into phone numbers, IDs, or other fixed masks without the overhead of Perl formats. The module exposes a single function, is lightweight to use, and is available on CPAN with source on GitHub.

Chandra::EPUB is a lightweight EPUB reader written in Perl that uses the Chandra GUI framework to open and display .epub books. You can start it with a single open call or create a Chandra::EPUB object with options such as file, width, height and title and then call run to show the book in a window. The module loads the EPUB container and extracts chapters, CSS, images and the XHTML body so you can render or process the content. It is useful for adding a simple desktop EPUB viewer to Perl applications and is distributed under the Artistic License 2.0 with bugs tracked via CPAN RT.

Alien::libwebsockets is an Alien-style Perl module that makes the libwebsockets C library easy to use from Perl by either finding a system installation or downloading and building libwebsockets from source for you. It is designed to supply compiler and linker flags to build Perl XS or C extensions, and integrates with ExtUtils::MakeMaker so you can set CCFLAGS and LIBS from Alien::libwebsockets->cflags and ->libs. When it builds from source it enables SSL, zlib, and the permessage-deflate extension, and will also enable libev support if libev development headers are present. The module inherits Alien::Base behavior and provides a has_extensions method that reports whether permessage-deflate support is present, though that detection is only reliable for its own built "share" installs and not for some system-installed libraries. If you need a straightforward way to ensure libwebsockets is available to your Perl build process, this module handles the discovery and optional build for you.

Pod::Markdown::Githubert converts Perl POD documents into GitHub-flavored Markdown and is a subclass of Pod::Markdown so it follows that API while adding GitHub-aware improvements. It rewrites internal L</...> links to match GitHub heading ids, lets you embed literal GitHub Markdown with =for github-markdown blocks, and redirects perlXYZ links to perldoc.perl.org so Perl manual pages resolve correctly. Verbatim POD is emitted as fenced ``` code blocks with normalized indentation and robust handling of nested blocks and backticks. You can enable syntax highlighting globally or per block via the new hl_language setting or =for highlighter language=... markers and the module also escapes dollar signs and prefers asterisks for italics to avoid GitHub rendering quirks. The module requires a recent Pod::Markdown and the 0.05 release added the hl_language constructor parameter and method.

Pod::Simple is a stable, widely used Perl library for reading and parsing Pod, the lightweight documentation format used by Perl and CPAN modules. It provides a parsing framework you can use directly with ready-made formatters such as Pod::Simple::XHTML or subclass to write your own formatter to emit text, HTML, XML, RTF or other outputs. The parser handles encoding declarations and includes options to treat input as characters, to strip or normalize verbatim indentation, to expand tabs, and to collect parse errors for reporting, and it offers convenient one-liner helpers like filter() for quick conversions. Note that Pod::Simple does not try to parse Perl code itself so pod-like lines inside ordinary multi-line strings may be treated as pod unless they are protected by indentation or here-doc syntax. The module is actively maintained on GitHub and recent updates improve URL and manpage linking, add better fallbacks when HTML::Entities is not available, and fix Unicode encoding in URL fragments.