CPANscan

Dist::Zilla::PluginBundle::Author::GETTY is an opinionated Dist::Zilla bundle that wires together a ready-made, configurable pipeline for building, documenting, versioning, and releasing Perl distributions. It provides sane defaults for metadata, PodWeaver documentation, Git-based version management and changelog handling, optional GitHub release creation, hooks to run commands before or after build and release, and integrations for XS/Alien modules and Docker image builds, while letting you opt out of CPAN upload or install steps if you wish. The bundle exposes many toggles like including README.md, selecting build systems for XS, marking a distro as adoptable, and forwarding Alien or Docker settings so you do not have to assemble many plugins manually. Notable recent changes include a new version_finder option to restrict which files get $VERSION rewrites and smarter Docker handling where setting docker_image now auto-adds a default Docker subsection so a working Releaser is available without extra configuration. If you use Dist::Zilla and want a convenient, documented starting point for consistent releases, this bundle is very likely relevant.

OcToolkit is a Perl-based, Helm-like toolkit for managing OpenShift and Kubernetes projects that emphasizes template-driven deployments and multi-cluster workflows. It converts Template Toolkit files into YAML, runs oc or kubectl to install, validate, upgrade, back up, and delete resources, and can compare live cluster state to offline templates to flag modifications. The module is highly configurable and extensible with callbacks for URL generation, component filtering, clutter removal, and flag-driven configuration, and it includes built-in secret handling that reads secrets from a directory and embeds them as base64-encoded data. If you prefer a Perl-centric, customizable alternative to Helm or need per-cluster control and scripted lifecycle management, OcToolkit provides the core features and hooks to integrate into automated workflows.

Net::DHCPv6 is an alpha-stage Perl library that encodes and decodes DHCPv6 network packets so you can turn raw wire bytes into high-level Packet, DUID and OptionList objects and build packets for transmission. It offers three decoding modes to suit different needs: decode_or_croak for strict parsing that throws on any error, decode_or_null for tolerant parsing that returns undef on failure, and decode_with_error for inspect-mode parsing that returns a packet and an error string for partial results. The module also includes helpers to parse raw DUIDs and option TLV chains without a full packet wrapper, which is useful for relay messages and sub-option payloads, and loading Net::DHCPv6 makes the related classes available while Packet->new delegates to the strict decoder. This initial 0.001 release implements common DHCPv6 message types and options such as ClientId, ServerId, IANA and IAAddr and supports multiple DUID formats, and the author notes the interface is experimental and may change.

Minion::Backend::SQLite is a lightweight SQLite-backed storage engine for the Minion job queue that uses Mojo::SQLite to store jobs, workers, locks and metadata and automatically creates the required schema. It plugs directly into Minion or the Mojolicious Minion plugin and is convenient for local development, single-server deployments or apps that prefer a file or in-memory database, with support for sharing an existing Mojo::SQLite connection. The backend implements the full Minion API including enqueueing, dequeueing with priorities and task filters, retries, locks, job and worker listing, stats and maintenance operations, and now supports cron-style recurring schedules with schedule, unschedule, pause_schedule, resume_schedule and dispatch_schedules methods added in the recent 6.0.0 release. Overall it provides a practical, easy to configure job queue backend when you want the simplicity and portability of SQLite combined with Minion's features.

Sys::GetRandom::PP is a pure-Perl wrapper around the operating system getrandom syscall that lets Perl programs obtain secure random bytes without using a C extension or opening /dev/urandom. It provides getrandom, which fills a scalar with up to the requested number of bytes and honors the GRND_RANDOM and GRND_NONBLOCK flags, and a convenience random_bytes function that returns up to 256 bytes. Because it uses Perl's syscall it is portable across several Unix-like systems supported by the author and is a drop-in Perl alternative to the Sys::GetRandom C module when you want to avoid XS or file handles. Note that getrandom may block until the kernel RNG is initialized unless you use the nonblocking flag and that random_bytes is limited to 0..256 bytes. Recent releases removed the build dependency on system header tools by hardcoding known syscall numbers to make the module easier to distribute and added clearer behavior and error messages on unsupported platforms.

DBIx::QuickORM is a Perl library for building database ORMs out of small, reusable pieces so you can declare databases, servers, schemas, tables, columns, relationships, and custom row classes with a compact builder-style DSL and compose them across projects. It supports multiple servers and databases, can auto-generate schema definitions by inspecting a live database, and lets you attach plugins, custom SQL types, and per-table or per-row behavior so your data objects map cleanly to your database layout. Recent updates add a DSL-free quick() factory that returns a ready-to-use ORM and connection, a DuckDB dialect, a lazy DateTime type, and other usability and performance improvements, making it a good fit for Perl developers who want a flexible, composable ORM that can be driven either by code or by introspection; start with the included QuickStart and the Manual to see examples and decide if its builder approach matches your workflow.

Genealogy::Military::Branch is a compact Perl module that scans free‑text military service notes from genealogy records and returns the branch named, for example "navy", "RAF" or "Royal Engineers". It supports common British, US and Commonwealth patterns and returns results localized to the system language or to a language you supply at construction. The API is simple: construct a detector with optional language and warn_on_error settings, then call detect with the text to scan; it never returns undef and will return a generic localized "military" when no specific branch is found. Patterns are tried from most specific to least so phrases like "Merchant Navy" are identified correctly. The module was created to replace duplicated helper code in related genealogy distributions and is intended to be extended with additional Commonwealth and US branch patterns in future.

DBIx::QuickDB makes it trivial to spin up temporary, disposable database servers for testing or local development across multiple engines so you can get a real DB to connect to with minimal setup. You can declare named databases at compile time that provide constants or build them on the fly at runtime and each returned DB object exposes a connect method. Supported drivers include PostgreSQL, MySQL variants, SQLite and, as of the latest release, an optional DuckDB driver when DBD::DuckDB and the duckdb CLI are available. Configuration is flexible via a spec hash where you control autostart/autostop, bootstrap and cleanup behavior, a custom directory, explicit driver choices or a list of acceptable drivers, and preload SQL files so your schema is ready. The module is designed for test isolation and convenience with features like cloning and pools, it defaults to cleaning up temporary directories so do not point it at anything important, and recent releases improved cleanup and fixed leaks while adding DuckDB support.

Concierge::Users is a Perl module that provides a ready-made user data layer with a clear two-step workflow for setup and runtime. During setup you define the storage backend, choose which built-in and custom fields you want, and the module writes a config and prepares storage, archiving any existing data to avoid loss. At runtime you load that config and get a simple CRUD API for registering, retrieving, updating, listing and deleting users, with consistent hashref return values indicating success or failure. You can store users in SQLite, a flat CSV or TSV file, or individual YAML files depending on your needs, and all backends expose the same interface. Field validation is built in with many common validators and can be enforced or skipped for bulk imports, and list_users supports a compact filter DSL for queries. Concierge::Users pairs with Concierge::Auth and Concierge::Sessions but also works standalone, making it useful when you want a configurable, schema-driven user store without writing storage plumbing yourself.

Concierge::Sessions is a Perl session manager that provides a simple factory-style API for creating, retrieving, deleting and cleaning up user sessions while letting you choose where those sessions are stored. It supports a production-ready SQLite backend and a lightweight JSON file backend for testing, enforces one active session per user, offers sliding-window expiration plus optional indefinite sessions, and returns consistent service-style hashrefs so your application can handle success and error conditions cleanly. The module is modern Perl (v5.36+) and is suited for web apps, APIs, or any service that needs application-controlled, serializable session data with optional persistence and periodic cleanup. Recent releases expanded test coverage and earlier updates hardened session ID generation for improved security.

Concierge::Auth is a compact Perl authentication component that hashes passwords with Argon2 while accepting legacy bcrypt hashes for smooth migration, stores credentials in a locked, file-based store, and also provides a suite of cryptographically secure token and random-value generators. It validates user IDs and passwords against sensible length and character rules, exposes safe file management utilities, and follows a non-throwing API where methods return a boolean plus an explanatory message so callers can handle outcomes gracefully. The generators can be used even when no password file is configured and include v4 UUIDs, hex IDs, alphanumeric tokens, random strings, and word-based passphrases produced via Crypt::PRNG rather than external programs. The project integrates with the broader Concierge suite but works standalone, and recent releases have cleaned up deprecated token APIs and improved generator behavior while expanding test coverage for greater reliability.

Thunderhorse is a modern, async-ready Perl web framework built natively on the PAGI protocol that aims to be light, extensible and hackable for real-time web applications. It includes a cache-friendly router with rich placeholder and bridge semantics, controller-based organization, modules for logging, templating and middleware, a flexible configuration system with smart merging rules, and a CLI for scaffolding and inspecting projects. The framework deliberately keeps dependencies small and leverages Perl 5.40 language features for performance and clarity, making it easy to mount PAGI apps or reuse components elsewhere. The project is currently in beta so APIs may change before the planned 1.000 release, but recent releases added a lazily created stash and a session object on the request Context to simplify session-aware handlers and avoid unnecessary work when the stash is unused. If you are building asynchronous or real-time services with PAGI and want a minimal, well-organized framework that integrates PAGI middleware and promotes reuse, Thunderhorse is worth evaluating.

Gears is a modular toolkit for building web frameworks in Perl that supplies the core building blocks you need, including an application container, a component system with lifecycle hooks, controllers, routing, configuration, templating, logging and request context handling. It is intended as a foundation rather than a full opinionated framework so you can mix, extend or replace components to shape the behavior you want in your own framework. The distribution also provides convenient utilities such as load_component to lazily load component classes and get_component_name to compose component namespaces from short names. Gears is currently in beta so APIs may change until a stable 1.000 release, and recent updates include test fixes and a small bugfix for a logger namespace issue.

Dist::Zilla::Plugin::IRC is a tiny Dist::Zilla plugin that adds an IRC channel entry to your distribution metadata so users can find the project's chat room. You enable it in your dist.ini with a stanza like [IRC] and channel = distzilla and you can optionally set network (defaults to "perl" but accepts values such as "libera", "freenode", or "oftc") or supply an explicit host to control the resulting link. It is useful when you want to advertise a real-time support or community channel alongside other resources in your CPAN distribution.

Task::Devel::Essentials is a lightweight meta-module that installs a curated toolkit of commonly used Perl modules so you can set up a developer environment with one cpan or cpanm command. It brings together testing and QA tools, profilers, packaging helpers, object systems like Moose/Moo/Mouse, JSON/YAML, file and date utilities, networking and MIME helpers, and many small conveniences that most Perl authors use every day, with a few optional XS or GNU-readline variants included where available. If you want a ready-made collection rather than picking dozens of dependencies by hand, this bundle saves time and keeps your toolchain consistent. The package was recently bumped to newer bundled versions, added CPAN::DistnameInfo, and moved its repository and issue tracker to Codeberg.

ClearPress is a lightweight, pragmatic Perl web framework that provides a simple, scaffolded way to build CRUD-style applications with a loosely MVC-inspired layout. It prescribes a project structure with a controller script, model and view modules, and Template Toolkit templates so you can quickly create list, add, edit, read, update and delete pages. Models are explicit Perl classes that declare their fields and use Class::Accessor-generated accessors instead of inspecting the database for schema, and the framework offers helpers for common associations and templates get convenient objects like the requestor and model injected. There is no built-in authentication and views behave more like controllers than in a strict MVC pattern, but that minimalism makes ClearPress well suited for rapid development and straightforward deployment using standard Perl components such as CGI, Template and Config::IniFiles.

Perl7::Handy provides a Perl 7-style scripting environment for older Perl 5 interpreters by importing safer, modern defaults into the caller package. It enables strict and warnings where supported, disables legacy bareword filehandles and multidimensional array emulation, enables subroutine signatures on capable Perls, lexically disables the indirect call feature, and removes the current directory from @INC to address a known security issue. The module runs on Perl 5.00503 and later and will use optional helper modules when available, with some behaviors only available on newer Perl releases. Use Perl7::Handy when you want the safer, modern defaults of Perl 7 for your scripts without upgrading your Perl interpreter.

Params::Validate::Strict is a Perl utility for checking and coercing function or API parameters against a rich, declarative schema so you can enforce types and business rules before your code runs. You describe each parameter with simple types or detailed rules for length, numeric ranges, regexes, allowed or forbidden values, transforms, defaults and optionality, and the module also supports nested structures, per-element checks for arrays, reusable custom types, cross-field validators and relationship rules like mutually exclusive or required groups. Validation returns a new hashref of validated and coerced values or dies with a clear error by default though you can configure warnings or ignore unknown parameters and plug in a logger. It is handy for API input checking, web application firewalls, improving documentation and driving black-box test case generation.

Mojo::SQLite is a lightweight Mojolicious-aware wrapper around DBD::SQLite that makes embedding SQLite in web apps straightforward by providing pooled, fork-safe connections, built‑in schema migrations, SQL generation via SQL::Abstract::Pg and convenient query and result helpers. It uses synchronous DBI calls and raises exceptions for errors, supports transactions and JSON parameters, caches handles for performance and emits a connection event when new connections are created. You can enable WAL journaling for better concurrent read/write behavior but note that as of v4.0.0 WAL is off by default for new databases and remains persistent once set, and in-memory databases are per-connection only. If you need a compact, well integrated SQLite backend for a Mojolicious app with easy migrations and CRUD generation, Mojo::SQLite is a good fit.

Net::BCCN is a small Perl module that implements a lightweight LISTEN/NOTIFY style notification fabric over UDP broadcast for a single local network segment. It lets processes and machines broadcast short, opaque messages on named channels without a central broker so you can publish events with notify(channel,payload) and receive them with listen(channel,options). The module handles socket setup, optional per-message deduplication and simple message-rate statistics, and uses nonblocking I/O with an optional timeout for efficient polling. It is intentionally fire-and-forget with no acknowledgements, persistence, or replay so occasional packet loss is expected. Envelope-level integrity and directed or multicast delivery are part of the protocol design but are not yet implemented in this release. This is the initial CPAN release (version 1.11, 2026-05-25).

Protocol::Tus is a Perl implementation of the Tus resumable upload protocol that makes it easy to accept, resume, and manage large file uploads from web clients. It offers a framework-agnostic API centered on HTTP_request, which takes an HTTP method, headers, an optional upload id and a body scalar reference and returns a Protocol::Tus::Response object for your application to turn into an HTTP reply. Storage is pluggable via a model object that implements the Protocol::Tus::AbstractModel interface or via a class spec such as Protocol::Tus::LocalDir for filesystem storage. Convenience methods cover the common HTTP verbs used by Tus including POST, PATCH, HEAD, OPTIONS and DELETE and the module honors X-HTTP-Method-Override for middleware compatibility. You can supply an id_to_location callback to generate Location headers after creating uploads and you are responsible for mapping URL paths to upload identifiers. Methods return response objects rather than throwing exceptions and the module requires Perl 5.24 or later. This is the initial 0.001 release.

IO::Tty is a low-level Perl module that allocates pseudo-terminals and exports the constants you need to work with them, but it is intended to be used internally by IO::Pty so most users should use IO::Pty to create ptys rather than calling IO::Tty directly. It supports modern POSIX systems and Cygwin and is tested on Linux, macOS, FreeBSD, OpenBSD and NetBSD, with known platform quirks documented in the POD because pty behavior is system dependent. The module is useful if you need direct control over pty allocation or just want the ioctl and terminal constants from IO::Tty::Constant. Recent 1.31 fixes a regression that stopped the slave from becoming a controlling terminal by always passing O_NOCTTY and improves openpty detection on some glibc builds.

YAML::Syck is a fast, lightweight Perl interface to the libsyck serializer that converts Perl data structures to YAML and back with simple functions like Load, Dump, LoadFile and DumpFile, plus newer encoding-aware helpers such as LoadBytes and LoadUTF8. It is designed for speed and interoperability with other Syck/YAML bindings and offers configurable behaviors through global flags for implicit typing, Unicode handling, key sorting and how code or blessed objects are treated. The module implements YAML 1.0 and bundles its own libsyck sources, so it may not match newer YAML 1.1/1.2 semantics and the author notes it has known issues and is only semi-actively maintained, so you may prefer YAML::XS for strict YAML 1.1/1.2 compatibility. Recent maintenance releases have fixed a number of parsing and memory issues and, as of 1.46, ensure numeric-looking strings are preserved as strings when dumping and accept trailing commas in flow sequences and mappings for better round-trip fidelity.

Concierge is a lightweight service-layer orchestrator that centralizes user authentication, session management, and user record storage for Perl applications, presenting a single, simple API and Concierge::User objects instead of exposing the underlying components. It wires together three pluggable cores for passwords, sessions, and user data so you can create a "desk" directory with Concierge::Setup and then open that desk at runtime to register users, create visitor or guest sessions, authenticate logins, restore users from cookies, and manage user records and passwords, with every method returning a clear success/message result rather than throwing exceptions. The module supports anonymous visitors, temporary guest sessions that can be upgraded to logged-in accounts, and persistent user records, and it persists a random user_key mapping to make cookie-based restores reliable. If you need custom backends or extra record types you can swap any of the core components for a drop-in replacement and add new components that follow the same conventions. The recent 0.7.0 release added Concierge::Base and expanded the extensibility documentation to make building and attaching new components easier.

App::Test::Generator is a toolkit that automates the creation of thorough test harnesses for Perl modules by turning simple input/output schemas into ready-to-run .t scripts that mix randomized fuzzing, deterministic boundary checks, optional static corpora, and property-based tests. You feed it a YAML or Perl schema describing function parameters and expected outputs and it generates Test::Most/Test::LectroTest-based tests that handle functional and OO calls, seedable reproducible fuzz runs, semantic generators for realistic data, transform-based invariants, and configurable edge cases for strings, numbers, arrays and hashes. The suite ties into mutation testing and LCSAJ metrics so surviving mutants can drive new schemas and tests, and it can produce a mutation and coverage dashboard and CI-ready workflows for continuous fuzzing. Helpers for serializing Perl values into test code and a SchemaExtractor that infers schemas from POD and source make it easy to bootstrap tests from existing modules. The recent 0.39 release tightens the mutation dashboard scoring and fixes a range of SchemaExtractor edge cases by adding Input formal spec parsing, better list-return handling, and several false positive fixes so the generated schemas and mutant-guided tests are more accurate and reliable.

Error::Show is a utility for locating and diagnosing Perl syntax errors and runtime exceptions by printing numbered, annotated source code around the problem and a readable stack trace. You can enable it from the command line with -MError::Show to have Perl run normally while the module intercepts syntax errors and warnings and emits context, optionally piping explanations through the diagnostics helper splain. Inside programs it exports a context function that accepts a die string or common CPAN exception objects and returns nicely formatted code snippets and frame context, and it integrates with several popular exception classes. For debugging dynamically generated code it provides streval, which preserves the original string so Error::Show can show accurate context and traces, and throw to create a simple exception object with captured frames when you need a lightweight throw. Recent releases added streval and throw and in v0.5.1 introduced an option to limit reported call stack depth while tidying output formatting. You can tune output with options for pre and post lines, limits, reversing order, and whether to include the raw Perl error text, and you should note it does not support programs supplied via STDIN or Perl -e and -E switches and splain may produce more output than ideal.

Git::Libgit2 provides low-level FFI::Platypus bindings to the libgit2 C library via Alien::Libgit2 so you can call libgit2 functions directly from Perl. It exposes a near-C API for initializing and shutting down the library, querying the version, checking return codes and converting object IDs, and for working with repositories, refs, blobs, trees and commits as well as remotes and authentication, clone/fetch/push operations, revwalks, branches, tags, diffs, status and related helpers. The module is intentionally close to the C surface, making it a good fit when you need direct, fine-grained control or plan to build higher-level helpers, and if you prefer an idiomatic Perl wrapper with RAII you can use Git::Native instead. This initial 0.001 release ships a broad set of bindings and has been tested against libgit2 1.5 and 1.9.

WWW::MailboxOrg is a Perl client for the Mailbox.org API that makes it simple to automate and manage Mailbox.org accounts and services from Perl programs. It speaks JSON-RPC 2.0 over HTTPS and uses session tokens for authentication, letting you log in and out and then call API areas such as account, domain, mail, mailing list, blacklist, spam protection, video chat, backup, invoices, password reset, validation and utility functions through dedicated helper objects. The module defaults to the official API endpoint and stores the session token for subsequent calls so you can focus on tasks like listing accounts, querying domain info or managing mail settings rather than HTTP plumbing. It is suitable for Perl developers who need to integrate Mailbox.org administration or mail workflows into scripts and applications, and links to the upstream API documentation and a GitHub issue tracker for support and contributions.

Travel::Status::DE::DBRIS is an unofficial Perl client for bahn.de that helps you fetch live departure boards, search stations by name or coordinates, and retrieve trip details and carriage formation for German trains. You can use it synchronously or asynchronously with promises and Mojo::UserAgent, and it returns rich objects for departures, journeys, locations, and formations so you can easily display times, delays, lines, destinations and route stops. The module supports optional caching to reduce repeated realtime requests, a failure cache to avoid hammering the backend, filtering by modes of transit, fetching intermediate stops, and injecting prepared JSON for testing. It is actively maintained but still described as work in progress and includes mitigations for Deutsche Bahn's rate limiting and web application firewall, so you should use sensible caching and request rates. Recent releases add nicer location output by showing distances when GIS::Distance is installed and keep train and operator names up to date to match backend changes.

Hypersonic is a Perl micro HTTP server that JIT-compiles your routes and its event loop into native C so the hot path can run with virtually no Perl overhead, delivering very high throughput. Static route handlers are executed once at compile() time and their complete HTTP responses are baked into C as constants, while dynamic routes still invoke Perl per request with JIT-compiled request objects where needed. It supports WebSocket connections and optional room-based broadcasts, server-sent events and streaming responses, TLS via OpenSSL, gzip compression compiled into the server, sessions, an async thread pool, and on-disk caching of compiled XS modules, so it is well suited for low-latency APIs, static asset serving, and benchmarking. You register routes with familiar get/post/websocket/static methods, call compile() to generate and build the native code, then run() to start workers and listen on a port. The module is explicitly performance-focused and claims very high request rates, and its JIT features require a C toolchain and native libraries such as zlib for compression and OpenSSL for TLS.