CPANscan

Apache2::API is a convenience framework that wraps the mod_perl2 Apache API into a single, easy-to-use object for building HTTP handlers and responses in Perl. It gives you request and response objects, helpers to encode and decode JSON, UTF-8, URL and base64 payloads, built-in logging and error/bailout handling, automatic JSON reply formatting, configurable response compression, Server-Sent Event support and cleanup callbacks, plus utilities like UUID generation and htpasswd/apr1_md5 password helpers. The module also exposes Apache and APR constants, supports localized messages and language formatting, and lets you inspect or register handlers for Apache phases. Recent releases added support for a retry_after property that sets the HTTP Retry-After header and fixed a security issue in password salt generation by requiring secure random sources, so it is a good fit if you need a consistent, JSON-oriented layer on top of mod_perl for building web APIs or handlers.

PAGI::FastAPI::Security provides a compact set of authentication helpers for the PAGI::FastAPI web framework, modeled after Python FastAPI's security utilities, to make it easy to extract credentials and present standard challenges. It includes ready-made schemes for HTTP Bearer, HTTP Basic, API keys via header/query/cookie, and an OAuth2 password-bearer helper, and it will produce the appropriate error metadata such as 401 plus WWW-Authenticate or 403 responses where applicable. The module intentionally stops short of validating tokens or passwords so you can plug in your preferred JWT, database or cache verification logic in a dependency handler, keeping the package lightweight and flexible. If you are building APIs with PAGI::FastAPI and want reliable, reusable credential extraction and challenge behavior without forcing a particular verification implementation, this module is likely relevant.

AWS::Lambda makes it easy to run Perl on AWS Lambda by providing a ready-made custom runtime, prebuilt Lambda Layers, zip archives and Docker images so you can deploy a simple Perl handler script or container image with minimal setup. It includes examples for packaging a handler, support for response streaming, built-in helpers for AWS X-Ray tracing, and an optional Paws layer for calling AWS services from your function, plus local testing workflows with Docker and the Lambda Runtime Interface Emulator. Common Perl modules are preinstalled and the package documents how to build custom module layers for additional libraries. Supported Perl versions follow the official Perl policy and Amazon Linux 2023 is the recommended platform, while older provided and AL2 layers remain available only for backward compatibility and are no longer maintained. This module is a good fit if you want to run Perl code on Lambda without building your own runtime from scratch or if you need an easy way to add Perl-based AWS SDK support.

Hyperman is a high-performance PSGI web server for Perl that combines a prefork supervisor with a per-worker XS event loop to serve synchronous and asynchronous apps with very low overhead. It runs any Plack app and lets handlers return a Hyperman::Future or any Future-compatible object so you can write nonblocking request handlers while the worker pumps its own loop. Hyperman supports TLS including SNI and optional/required client certs, cleartext and ALPN HTTP/2, multiple listeners per process with built-in https redirect, and production features like graceful drain, worker respawn and zero-downtime restarts. Logging can be done with a fast C-written Combined Log Format writer or a Perl coderef for custom handling. The module exposes timer and io_ready futures plus per-worker stats and also publishes a public C ABI so other XS modules can drive the loop and create or settle futures entirely from C. Recent releases added a stable public C ABI, HTTP/1 chunked-body decoding, hardening against request smuggling, multi-listener support and a fast builtin access log, making Hyperman a good fit if you need a low-latency, high-throughput PSGI server with async primitives and tight C integration.

Sereal::Encoder is a Perl module that turns in-memory Perl data structures into a compact, fast binary representation called Sereal, suitable for storage or fast IPC, and pairs with a separately released Sereal::Decoder for reading the data back. You can use it as a reusable encoder object or via convenience functions to serialize values or write them directly to files, and it offers many knobs such as optional compression with Snappy, zlib or Zstd, string deduplication, control over how blessed objects are handled, and a FREEZE/THAW callback mechanism so objects can provide their own serialization form. It also supports features to produce a more canonical byte representation for caching or comparison, and provides performance-oriented advice to prefer the object or sereal_encode_with_object interfaces over the one-shot functional call. The module is thread-safe on modern Perls and actively tuned for speed and compact output, but users should be aware of Perl-specific serialization subtleties such as string versus numeric representations and dualvars which can affect round-tripping in edge cases, and recent protocol versions add explicit boolean support.

Sereal::Decoder is a fast, C-backed Perl module for deserializing data encoded with the compact Sereal binary format so you can reconstruct Perl structures quickly and with low overhead. It provides an object-oriented decoder (plus faster functional wrappers) with methods to decode whole packets, read optional header data, parse from files or offsets, and report how many bytes were consumed so you can handle concatenated streams or incremental feeds. The decoder supports modern Sereal protocol versions (including protocol 5 in recent releases) and common compressors such as zstd and snappy while offering a range of safety and tuning options like refusing compressed input, rejecting or not blessing objects, whitelisting which classes may run THAW callbacks, UTF-8 validation, recursion and size limits, incremental parsing, and readonly outputs. It also implements the FREEZE/THAW hook for complex object serialization but warns that THAW executes class code so you should enable the defensive options when handling untrusted data. Recent updates improved thaw ordering, fixed rare crash scenarios around frozen-object state, and added protocol 5 support, so upgrade the decoder before upgrading any Sereal encoder.

Sereal is a Perl module that provides a fast, compact binary serialization format by bundling the Sereal::Encoder and Sereal::Decoder implementations into a single thin wrapper. It is aimed at high-performance use cases such as IPC, caching, network transport and on-disk persistence and handles complex Perl data structures, freeze/thaw hooks, and a range of numeric types. For best speed you should use the object-oriented Encoder/Decoder interface but convenient exported functions exist for simpler tasks and there are helpers to obtain shared encoder/decoder objects, clear their caches, and read or write sereal packets to files. The implementation supports multiple compression backends including Snappy, zlib and Zstd and exports constants for those modes. Because encoder and decoder are released separately the module ensures compatible versions are loaded and warns that you should upgrade decoders before encoders; recent notable work includes the protocol 5 release with improved floating point handling, support for newer Perl bools and various build and security fixes.

Test::Returns is a small testing helper for Perl that makes it easy to assert that a function or method return value conforms to a declared schema. It exports readable helpers like returns_ok and returns_not_ok that validate values via Return::Set and Params::Validate::Strict and integrate with Test::Builder so they work alongside Test::More and Test::Most. The module accepts type => 'array' as a convenient synonym for 'arrayref' and passes through underscore-prefixed schema keys used by some generators. It is minimal, GPL2-licensed, and provided as-is without warranty.

Module::Generic is a feature-rich base class for building Perl objects quickly that supplies a large toolkit of reusable helpers so you can focus on your domain logic rather than boilerplate. It provides flexible, type-aware getter/setter helpers for scalars, numbers, booleans, dates, IPs, UUIDs, arrays and nested object trees, a create_class helper to generate classes and accessor methods on the fly, AUTOLOAD-based dynamic access to hash keys, and convenient facilities for serialization, cloning, structured error/exception objects, debug and colorized terminal messages. Many utility routines are lazy-loaded to reduce memory use and performance-critical checks are implemented in optional XS with pure-Perl fallbacks if the XS backend is not available. The design favors non-fatal error handling by returning undef and an exception object instead of dying, which makes it easy to propagate and inspect errors consistently. It also includes helpers for loading classes, instantiating related objects, pretty-printing and dumping data, and thread/process-aware global error storage. Note that a few metaprogramming features such as dynamic symbol insertion and runtime class creation carry thread-safety caveats and some functionality depends on optional CPAN modules, so preload or avoid those at runtime in threaded contexts if that matters for your application. If you are writing Perl modules or applications that need rapid, consistent creation of typed accessors, nested object models and common utilities, Module::Generic can save a lot of time.

Net::Firewall::BlockerHelper is a lightweight Perl helper for programmatically managing IP bans across multiple firewall backends. It exposes a simple API to initialize and teardown firewall rules, ban and unban IPv4 and IPv6 addresses, handle CIDR ranges when the chosen backend supports them, list current bans, flush all bans, and reapply rules. The module validates ports, protocols, IPs and CIDRs, offers a configurable self_heal mode that checks and restores the backend setup before each action, and delegates actual rule work to backend implementations such as ipfw. Error handling is done via Error::Helper and failures are treated as fatal, making this module a practical choice for scripts or services that need a uniform way to manage blocking across different firewalls.

Lingua::TokiPona::Word is a small utility for representing and working with words in the miniature language Toki Pona. It creates normalized, deduplicated word objects from either a plain string or another identifier object and provides a simple API to get the word back as text, test equality, and perform a stable ordering via cmp with the usual Perl operator overloads. The module builds on Data::Identifier interfaces so it is useful when you need canonical, comparable word objects for parsing, indexing, or manipulating Toki Pona text. This is the initial release and offers the core behaviors of normalization, deduplication, string conversion, equality checks, and a stable but not strictly specified sort order.

Concierge is an extensible service layer that handles user identity, sessions, and user records for applications by coordinating three core components, Auth, Sessions, and Users, and by allowing additional pluggable components to be attached to a desk, which is a directory holding the app's concierge configuration and storage. It exposes simple lifecycle calls for visitors, guests, and logged in users so you can create anonymous trackers, session-backed guests, authenticate users, restore sessions from user keys, convert guests to accounts, and manage sessions and passwords while keeping credentials out of user records. All API calls return structured hashrefs with clear success and message fields so your application always retains control and errors are reported instead of failing silently. The system is backend-agnostic so you can swap or add storage and auth backends and optionally defer expensive component initialization until first use. Recent notable changes in v0.13.0 removed the earlier feature that promoted component methods into the concierge itself so added components must now be called through their component object, and added user-level mirror methods verify_password, reset_password, and logout so returned user objects can perform those checks and updates directly. If you need a reliable, pluggable identity and session orchestration layer that keeps operational resources separate from application logic, Concierge is a good fit.

Crypt::SMIME is a Perl module that provides a simple object interface for creating and consuming S/MIME messages so you can sign, verify, encrypt and decrypt MIME mail using OpenSSL's libcrypto. You give it your private key and certificate as PEM strings or load them from PKCS#12, point it at trusted certificate stores, then call sign, check, encrypt or decrypt and use helper methods like isSigned, isEncrypted, extractCertificates and getSigners to inspect messages. It supports detached signatures, lets you choose the cipher for encryption, can check certificate revocation lists and lets you set the verification time, and it follows Perl tainting rules when inputs are tainted. Recent releases modernized OpenSSL support by requiring OpenSSL 3.0 or newer, added support for AEAD ciphers such as AES-GCM and an explicit cipher argument for encrypt, added getCapabilities and CRL-check flags, and include build fixes for OpenSSL 4.0 and Windows.

Dist::Zilla::PluginBundle::Author::GETTY is a ready-made Dist::Zilla configuration bundle that wires up the author GETTY's preferred plugins and sensible defaults so you can build, test, and release Perl distributions with minimal setup. It handles versioning, metadata, PodWeaver, Git-based version management and release commits, optional GitHub release publishing, install-after-release, and support for XS or Alien-based C libraries, plus convenient hooks to run scripts before or after build and release. The bundle auto-detects GitHub remotes but can emit generic or Gitea/Forgejo metadata for self-hosted forges, excludes README.md from release tarballs by default, and can also add Docker image build and CI wiring through a shared GitHub Action, so it suits pure-Perl modules, XS modules, and packaged C-library wraps. Configuration options let you opt out of particular behaviors, mark a dist as up for adoption, add IRC support in metadata, restrict which files get $VERSION rewritten, and pass through Alien or Docker settings without manual plugin plumbing. Notable recent change in v0.317 adds a tag_format option so you can control the format of Git tags produced at release time, for example to prepend a v for other ecosystems while keeping Perl version semantics intact.

Mojolicious::Plugin::Fondation is a plugin manager for Mojolicious that helps you compose web apps from reusable modules by loading plugins recursively, resolving dependencies, and merging configuration and resources in a predictable way. It combines configuration from three sources with a clear priority (direct overrides, then application config, then plugin defaults) and concatenates arrays so apps can extend lists such as dependencies or roles. Fondation automatically exposes plugin share/templates and share/public directories to your app, wires plugin controller namespaces into the router, and performs configurable post-load actions like Templates, Controllers and Static, then calls an optional fondation_finalyze hook for plugins that return $self from register. The framework also supplies helpers including a manager accessor and render_zone/render_zone_js for injecting HTML and JS fragments from plugins into layout zones, and it supports custom action classes for additional initialization work. Recent releases added clearer action logging so you can see which plugin an action runs on, provided JavaScript and date-format fallbacks, and added conveniences like scanning a development plugins directory.

Dist::Zilla::PluginBundle::DROLSKY is the personal Dist::Zilla plugin bundle used by Dave Rolsky to assemble and configure the many plugins he uses to build, test, document, and release Perl distributions. It acts like a ready-made dist.ini that wires up metadata generation, versioning, Git integration, test suites, Pod checks and spelling, license and contributors handling, AutoPrereqs detection, Readme generation, optional PPPort support for XS code, and a host of other release-time conveniences, while allowing per-plugin removal or reconfiguration. The bundle is intended as a blueprint rather than a drop-in for other authors, so you will likely consult it for ideas and patterns rather than copy it verbatim, and you can find its source and bug tracker on GitHub if you want to inspect or adapt it.

App::MARC::Filter is a lightweight Perl base class that powers a simple command line utility for selecting and extracting MARC bibliographic records. It reads common MARC formats including MARCXML and USMARC and can handle compressed input files, then filters records by datafield tag and subfield, control fields, leader content, or material type, with options to invert matches, limit the number of output records, and run in verbose mode. The module is aimed at librarians, catalogers, and developers who need a scriptable way to pull subsets of MARC data for analysis or conversion and it returns standard exit codes so it fits into shell workflows. Recent releases added support for compressed input and improved detection of XML files, making it more robust for real world MARC datasets.

Cavil::Matcher is a purpose-built pattern matcher used by the Cavil license-scanning tool to turn source files into license and keyword hits quickly and safely. It tokenizes text and then matches those tokens against compiled patterns using a proven token-hash prefix-tree algorithm, but stores patterns as immutable, memory-mapped segment files so workers on the same host share one physical copy and adding or removing a pattern does not require rebuilding the whole cache. The tokenizer and hashing are a frozen C++ core that is bit-for-bit compatible with the previous engine, while segment lifecycle and tooling are implemented in Perl so you get stable matching with efficient mmapped storage. The API includes helpers to parse pattern text (parse_tokens supports $SKIPn wildcards that match 1..n words), normalize input into tokens with line numbers, compute an approximate token edit distance that preserves parity with the old engine, and read raw file lines with a 1 MiB per-line cap to avoid pathological inputs. The Engine lets you add patterns, scan files for resolved matches, dump and load compiled segments, attach additional segments at runtime, verify on-disk integrity, set tombstones to exclude ids, and record generation metadata for race-free reporting. There is also a tf-idf "Bag" model for closest-match lookups and a streaming 128-bit hash helper. Note that parse_tokens and normalize treat their input as C-strings and stop at embedded NUL bytes, and the distance function intentionally reproduces an off-by-one behavior from the prior engine.

OSLV::Monitor is a Perl extension for LibreNMS that collects and reports metrics from OS-level virtualization environments such as FreeBSD jails or Linux cgroups. It auto-selects a backend based on the host OS or accepts an explicit backend, and is configured via a constructor with options for cache directory, include and exclude name patterns, and a time divider. The module exposes simple load and run methods that initialize the backend and poll for data, returning JSON-ready results for ingestion by LibreNMS. This makes it a handy way to add container and lightweight virtualization visibility to an existing LibreNMS deployment without deploying extra agents.

Open::API is a focused OpenAPI 3.1 toolkit that compiles a single spec at startup and gives you both a high-performance PSGI server and a spec-driven HTTP client. You hand it a hashref, JSON or YAML text, or a filename and it precompiles every parameter, header, cookie and body schema via JSON::Schema::Fast so routing and validation happen on a fast C path. Handlers are wired by operationId and receive typed, default-filled inputs with cookie parsing and decoded bodies, and you get optional response validation plus before and after hooks for authentication and response mutation. It supports nonblocking Futures on compatible servers, fails fast on malformed specs or duplicate operationIds, and the same compiled object drives Open::API::Client when Fetch is available. The module only supports OpenAPI 3.1, requires JSON::Schema::Fast, and is released as version 0.01.

Markdent is an event-driven Markdown parsing toolkit for Perl that emits fine-grained parse events so you can analyze, transform, or render Markdown in flexible ways beyond simple HTML conversion. It includes convenient helpers for quick Markdown-to-HTML output such as Markdent::Simple::Document and a markdent-html command line tool, and it provides handler classes for streaming HTML, filtering, multiplexing and capturing events to build custom processing pipelines. You can extend the parser with custom dialects or use the supplied GitHub and Theory dialects when you need nonstandard Markdown features, and captured event playback can speed up repeated rendering. The recent 0.41 release cleans up a warning on modern Perl (5.43.2+).

File::Raw::JSON is a lightweight, high-performance JSON and JSON Lines plugin for File::Raw that calls the bundled yyjson C library to parse and emit JSON with minimal overhead. It registers two plugins, "json" for single-document files and "jsonl" for NDJSON streams, and also exports file_json_decode and file_json_encode for in-memory conversions; you can slurp, spew, or stream records with memory-bounded callbacks, pretty-print or sort keys for diff-friendly output, and enable relaxed parsing or preserved insertion order when needed. The JSONL mode uses brace-balancing so pretty-printed records, multi-record lines, and braces inside strings are handled correctly, and the ordered decode option preserves object key order at a measurable performance cost. The module vendors yyjson under an MIT license and recent releases fixed cross-platform build issues, including FreeBSD, older GCC toolchains, and Strawberry/Win32 Perl builds.

App::karr is the core of karr, a Git-native kanban system that stores board state in Git refs under refs/karr/* instead of in the working tree, so task cards are simple Markdown files with optional YAML front matter and configuration lives in sparse YAML refs layered on code defaults. The tool materializes a temporary board view for each command, lets you inspect and modify tasks, then writes changes back into refs to avoid a persistent karr/ tree and ordinary file-level merge conflicts. It ships as the karr CLI plus reusable Perl modules like App::karr::Git, App::karr::BoardStore and App::karr::Task for automation, and provides Docker images tuned to avoid creating root-owned project files. The command auto-discovers the board by walking up from your current directory and shows a board summary when run without arguments. App::karr is a good fit when you want Git to remain the transport and single source of truth for simple project tracking and when you need programmatic access for scripts or CI.

LightTCP::Server is a lightweight, pure-Perl TCP/HTTP server that makes it easy to run a configurable web service for testing, local tools, or small deployments. It can run single-process, forked, or threaded, serves static files, executes CGI scripts, and provides callback hooks so you can implement custom request handling, logging, timeouts, and upload processing. The module includes built-in upload endpoints with size and MIME-type checks and filename sanitization, optional post-upload callbacks, plus configurable IP rate limiting and simple API key or Basic Auth support. Configuration is exposed through many attributes and accessors so you can tune ports, directories, thread limits, allowed file types, and host allow/deny behavior. Security features include basic path traversal protection and sanitized atomic saves for uploads. Known limitations are that it does not provide HTTPS or WebSocket support, rate limiting is kept in memory and resets on restart, and large uploads are buffered in memory, so this is best for internal, lightweight, or low-traffic use rather than high-security, high-scale production deployments.

Return::Set provides a single exported function, set_return, that returns a value and can optionally validate that value against a strict Params::Validate::Strict schema. You can call set_return with just a value to return it as-is, with a value and schema to validate before returning, or with a named-parameter hashref using "output" (or "value" for compatibility) and "schema". If validation fails the function croaks, which makes it useful when you want to formally declare and enforce a method's output types, especially when used alongside Params::Get. The module is small and focused, offering a simple way to add declarative runtime checks to your return values.

WebService::OurWorldInData is a lightweight Perl base client for accessing the Our World in Data APIs, providing shared HTTP handling used by endpoint-specific modules for charts, tables, indicators, and search. It performs the requests and returns the API responses as JSON so you can quickly pull observational data into Perl programs. The client supports proxied environments and lets you supply an HTTP::Tiny object with an all_proxy setting or rely on standard proxy environment variables. The OWID APIs are under active development, so this module focuses on forwarding raw JSON responses for now and will add higher-level result helpers as the API stabilizes.

App::DBBrowser is a terminal-based interactive database browser that helps you explore and manipulate SQLite, MySQL/MariaDB, PostgreSQL and many other databases through a menu-driven UI and a plugin system. It makes common tasks simple by letting you inspect schemas and tables, build and run SELECT/UPDATE/INSERT/DELETE statements with guided menus, use CTEs and window functions, import and export data, apply filters and scalar functions, and create or drop tables without memorizing SQL syntax. The tool is highly configurable with options for quoting, aliases, output formatting and input parsing, and it ships as the db-browser command for quick, hands-on database work on the command line. Version 2.444 enables extended columns by default and adds a Select DISTINCT option in the SELECT submenu, continuing a long history of refinements and broad driver support via plugins. If you need an interactive, terminal-focused way to inspect and edit databases without a graphical client, App::DBBrowser is likely relevant.

Business::ISBN::Data is the data package used by Business::ISBN to provide ISBN range, group and publisher code information drawn from the ISBN Agency's RangeMessage.xml. You normally do not load it yourself because Business::ISBN auto-loads it, but you can point the module at a different RangeMessage.xml by setting the ISBN_RANGE_MESSAGE environment variable or by placing the file in the current working directory. The distribution includes a copy of RangeMessage.xml and also embeds fallback data in %Business::ISBN::country_data so lookups still work if an external file is not available. The data are kept up to date with frequent releases from the ISBN Agency and recent fixes include stopping unintended autovivification and correcting ISBN-13 prefix handling, so use Business::ISBN 3.005 or later for correct ISBN-13 behavior.

SPVM::Go brings the goroutine and channel model from the Go language to SPVM, letting you spawn lightweight concurrent tasks and communicate safely with channels, select statements, wait groups, timers, and context support. It integrates libuv's event loop so goroutines suspend without busy-waiting and resume only when timers, I/O, or channel operations are ready, which keeps CPU use very low and allows thousands of concurrent goroutines in one process. The module exposes simple APIs to start goroutines, create channels, perform select operations, sleep or wait on I/O with timeouts, and handle signals, and it includes companion modules like Go::Channel, Go::Select, Go::Sync::WaitGroup, and Go::Context. Be aware that several scheduler operations must be called from the main thread and that I/O timeout values must fit the configured integer limits, otherwise exceptions are raised. The project is MIT licensed and maintained on GitHub.

Mojolicious::Plugin::BarefootJS plugs the BarefootJS server runtime into Mojolicious so you can call a per-request BarefootJS instance from your controllers and templates via the bf helper, render compiled BarefootJS templates as Mojolicious templates, and drive server-side rendering using the BarefootJS::Backend::Mojo adapter. It keeps integration simple and framework-native while the separate BarefootJS::Backend::Xslate offers the same runtime for non-Mojolicious or PSGI hosts. A recent improvement changed how the build manifest is loaded so it is read lazily and cached by mtime/size, which prevents boot-time race issues and allows manifest updates to be picked up without restarting the server.