CPANscan

Game::TileMap::Pathfinding provides a fast Breadth-First Search pathfinder for Game::TileMap grids, using an XS core for performance and returning a Game::TileMap::Pathfinding::Result that lists the sequence of steps from start to goal, with undef returned when no route exists. It can optionally allow diagonal movement with simple collision checks and a diagonal step cost scaled by sqrt(2). Instances build a map of accessible tiles at construction and can be reused for many queries but do not track later changes in terrain, so you should recreate the pathfinder if accessibility changes. The module assumes all terrain types have equal movement cost, making it a solid choice for simple, high-performance grid pathfinding in games and simulations.

Dist::Zilla::PluginBundle::GEEKRUTH is a ready-made collection of Dist::Zilla plugins that reproduces the release workflow D. Ruth Holloway uses for her Perl distributions, so you can apply her conventions for metadata, testing, packaging, changelogs, git tagging and pushing, and other release chores with minimal setup. It wires together a long list of common plugins for generating META files, collecting contributors, running compile and extra tests, weaving POD, enforcing license and security policy, managing branches and tags, baking INI files, and auto-detecting prerequisites, while letting you tweak key options such as authority (default cpan:GEEKRUTH), builder (MakeMaker by default), development and release branch names (main and releases), upstream remote (origin), and a remove_plugin hook to drop parts you do not want. If you publish CPAN distributions and like a reproducible, curated release process, this bundle saves configuration time and enforces a consistent toolchain. The recent 4.0002 rebuild fixes incorrect META information caused by a buggy Codeberg plugin and follows the author’s move to Codeberg and an expanded security policy in the 4.0000 series.

Dist::Zilla::PluginBundle::Codeberg is a convenience bundle for Dist::Zilla that wires in Codeberg support so you can publish and maintain CPAN distributions hosted on Codeberg. It automatically adds the Codeberg::Meta and Codeberg::Update plugins to populate META fields like homepage, bugtracker and wiki and to create or update the remote repository, and it picks up your Codeberg credentials from git config or an optional ~/.codeberg file created by Config::Identity; you must create a personal access token with the api scope. Configuration options let you control which homepage or bug URL gets written, which git remote to inspect, whether to follow upstream forks, and the explicit repo name when needed. If you use Dist::Zilla for releasing modules and host your code on Codeberg this bundle saves manual metadata and repo setup work. Recent releases update the module to use the Forgejo/Codeberg API and remove the installer entry from dist.ini.

Mail::MIMEDefang is a Perl-based framework for building high-performance email filters that integrate with Sendmail via the Milter API. It lets system administrators and developers write custom Perl filters to block viruses and spam, tag or strip HTML, modify or replace attachments, add disclaimers, implement access controls, and quarantine messages. The distribution provides helper routines for logging, status tracking, percent-encoding, sending mail safely via sendmail, and for detecting and loading support for antivirus and anti-spam tools, so you can focus on policy rather than plumbing. If you run Sendmail and want flexible, scriptable message processing in Perl, MIMEDefang gives you a ready-made, production-quality framework to implement it.

DBIx::QuickDB is a lightweight helper for test and development workflows that quickly creates disposable database servers you can connect to from Perl, with built‑in support for PostgreSQL, MySQL/MariaDB, SQLite and optional DuckDB. You can define named, globally available databases at compile time or build instances on the fly at runtime, then call connect on the returned object; configuration allows you to pick drivers or a priority list, point at or create a data directory, auto-start and auto-stop the server, run bootstrap SQL, load schema files, control cleanup, and opt out of global caching. Environment variables such as QDB_TMPDIR and DB_VERBOSE let you control the temp directory location and server output, and the module also supports cloning and pooling of instances for faster test cycles. The project has seen steady reliability improvements around startup, shutdown, cloning and cross-platform behavior, and the most recent release improves Windows cleanup by retrying directory removal and explicitly disconnecting DBI handles before deleting data directories so leftover file locks no longer leave stale databases behind. If you need ephemeral, configurable database instances for automated tests or local development without managing full system servers, DBIx::QuickDB is a practical, well‑maintained choice.

Syntax::Highlight::Basic is a small pure-Perl library that provides straightforward syntax highlighting for source code, designed for embedding highlighted snippets in HTML or terminal output. It converts Vim syntax files into compact runtime data and uses those patterns to classify tokens into familiar Vim-compatible highlight groups. The module emits Pygments-compatible CSS class names, HTML with inline color styles, or ANSI terminal color sequences and already includes support for over 80 languages plus a CLI and a vim-syntax-to-shb converter for bringing your own definitions. You create an instance with optional custom syntax_dirs to load user syntax files, then call highlight($code, $language, \%opts) to produce output with options for format and wrapping, and you can customize colors and CSS classes to match your site or terminal theme. This initial 0.1.0 release is a handy, dependency-free choice when you need flexible, Perl-native highlighting that integrates with existing Vim syntax definitions.

OpenSearch::Client is an unofficial Perl client that lets Perl programs talk to OpenSearch clusters using a familiar Search::Elasticsearch-derived API. It provides the common tasks you expect from a search client such as connecting to a server, indexing and retrieving documents, running searches and using helpers like bulk and scroll, while remaining compatible with OpenSearch after the fork from Elasticsearch. The distribution is a maintained successor to the older Elasticsearch Perl client and includes recent practical improvements such as proxy configuration options for http and https, better support for testing against AWS Managed or proxied OpenSearch endpoints, and a few option name tweaks; full usage details are in the OpenSearch::Client::Manual.

Fondation::I18N is a translation plugin for Fondation applications that replaces the default identity fallback helpers with real dictionary-based translations. At startup it scans each plugin's share/translations/<lang>.json files, merges them into per-language lexicons stored on the app and exposed via a helper, and notes that when keys conflict the last file seen wins. On each request a before_dispatch hook picks the user language from a URL prefix or the Accept-Language header and caches the appropriate lexicon in the request stash so the l() helper can resolve strings with a single hash lookup. It also provides i18n_js to embed the current language lexicon into client JavaScript and registers an /i18n/<lang>.json endpoint for dynamic lookups, and it supports configuring a default language and which languages may appear in the URL.

Aion::Emitter is a lightweight event dispatcher for the Aion framework that triggers handlers based on the class of an event object, letting you attach behavior to domain objects without wiring callers to specific listeners. Listeners are discovered via the "#@listen" annotation and registered once in Aion’s container so each listener is represented by a single object, and emit accepts an optional key to target a specific variant of an event such as a particular controller or context. The module is aimed at making simple publish/subscribe flows easy to implement in an application that uses Aion annotations and environment config, and the latest release adds has_event and clear_event helpers to manage emitted event state. If you use Aion and prefer annotation-driven, class-based events with optional scoping, this module is a concise solution.

Mojolicious::Plugin::Fondation::User::UI::Bootstrap is a Mojolicious plugin that adds a ready-made Bootstrap 5 web interface for user management in Fondation-based applications. It provides templates, JavaScript assets including a DataTable initializer, and translations so you can list users in a paged, editable table and manage roles, groups and activation through modal dialogs. The plugin registers a GET /users route protected by the "fondation.perm => user_list" condition and relies on Fondation::User and Fondation::Layout::Bootstrap while delegating create, edit and delete operations to the Fondation::Action::REST handlers. Configuration is minimal with an optional page title and the distribution ships with the EP templates, client-side modules and i18n lexicons. This is the initial 0.01 release.

Mojolicious::Plugin::Fondation::OpenAPI is a plugin for Fondation/Mojolicious apps that generates an OpenAPI 3.0.3 specification and client-side validators from DBIx::Class sources discovered via a configured DBIx::Async backend, and then uses that spec at runtime to validate requests and add Swagger UI in development. You run it with the bundled CLI command openapi generate to produce share/openapi.json and public/js/validators.js which are meant to be committed with your app and used by your asset pipeline, and the plugin also maps schema and permission overrides from your configuration so you can control which columns are writeOnly or required and which endpoints need specific permissions or groups. It honors per-plugin declarations of tables to exclude so internal tables are not exposed, and at startup the generated spec is loaded by Mojolicious::Plugin::OpenAPI to enforce request validation and translate x-auth rules into route-level requires conditions. The module requires Fondation::Model::DBIx::Async and recent Mojolicious::Plugin::OpenAPI/JSON::Validator, which can hit a compilation issue on Perl 5.40 due to Net::IDN::Encode but distributions like Debian provide a packaged workaround. Recent 0.02 changes tighten naming and defaults and synchronize permission metadata with Model::DBIx::Async to make generated APIs and authorization rules more consistent.

Mojolicious::Plugin::Fondation::User is a ready-made user management component for Mojolicious apps built on the Fondation set of plugins. It creates a complete "users" table with Result and ResultSet classes, supplies a REST controller with standard CRUD endpoints under /api/user, and provides an optional Bootstrap-based HTML UI. Passwords are automatically hashed with Argon2 using Crypt::Passphrase and the hashing work is offloaded to the DBIx::Class::Async worker so your event loop stays responsive. The API never exposes the password field. Handy ResultSet helpers let you query active users, users created today, or the latest users, and built-in translations include English and French. Use this module when you want a plug-and-play user schema, endpoints, and UI integrated into the Fondation/OpenAPI workflow.

Mojolicious::Plugin::Fondation::Setup provides an interactive web-based setup wizard for Fondation applications that discovers available plugins on MetaCPAN, reads each plugin's declared setup metadata, and builds a step-by-step configuration workflow served at /setup. Users can pick which plugins to enable, complete per-plugin configuration screens whose fields are pre-filled from any existing config, and persist progress using a file-backed workflow so no database is required. When the wizard completes it writes a $moniker.conf file with the selected plugins and their settings and shows a confirmation page, and it will warn if Mojolicious::Plugin::Config is not enabled so you know to load the generated config. This plugin is a convenient way to assemble and configure Fondation plugins through a guided UI rather than hand-editing configuration.

Mojolicious::Plugin::Fondation::SessionStore is a Fondation plugin that replaces Mojolicious default signed-cookie sessions with server-side session storage using Mojolicious::Sessions::Store. Instead of keeping session data inside a readable cookie, the browser receives only an opaque session ID while the full session data lives on the server, which improves security, allows server-side revocation of sessions, and avoids cookie size limits. It uses a file backend by default that stores JSON files and can be configured with custom backends, a storage directory, cookie name, and expiration time. The standard Mojolicious "session" helper keeps working unchanged, so you can adopt server-side sessions without reworking existing session code.

Mojolicious::Sessions::Store provides server-side session storage for Mojolicious by replacing the default signed-cookie approach with a signed cookie that contains only a session ID while the actual session data lives in a backend such as the filesystem, Redis, or a database. It subclasses Mojolicious::Sessions so the usual session helper in controllers keeps working unchanged, making it a simple drop-in when you need to store larger or more sensitive session data, share sessions across processes, or enforce server-side expiration. Backends must implement load, save, and delete and a file-based backend is included in this initial 0.01 release, and common session attributes like cookie_name, default_expiration, samesite, and secure are supported for easy integration.

App::karr is the engine behind the karr command line tool that gives you a Git-native kanban board by storing board configuration, tasks and logs inside Git refs under refs/karr/*. Tasks are simple Markdown files with YAML frontmatter and commands materialize a temporary board view, serialize edits back into refs, and push them so your repository tree stays unchanged and you avoid ordinary file-level merge conflicts. The distribution is aimed at projects that want Git to remain the single source of truth and it ships both a CLI and lower-level Perl modules you can use for automation, plus Docker images for running karr without installing Perl locally. If you want to keep task state alongside your code and manage cards through Git operations, this tool is a good fit.

Math::Float128 exposes C's quadmath __float128 type to Perl so you can create true 128-bit floating point objects, convert values from ints, floats or strings, and perform high-precision arithmetic with familiar overloaded operators. It supplies constructors and conversion helpers, stringification with configurable decimal precision, access to common quadmath constants, a large set of math library functions (trig, exp, log, gamma, etc.), and helpers to detect NaN, infinity or signed zero and to inspect the raw 128-bit bytes. Be aware that creating a Float128 from a Perl numeric versus a numeric string can produce different results unless your Perl uses __float128 for its native NV type, and some rounding-to-integer routines require Perl integer types large enough to hold C longs. The module includes workarounds for buggy quadmath functions on some older mingw-w64 compilers. If you need extended precision beyond IEEE double and have quadmath available, this module makes 128-bit floating math convenient from Perl.

Jacode4e is a pure-Perl character encoding converter tailored for Japanese enterprise and mainframe data, letting you convert strings in place between a wide range of legacy and modern encodings while preserving byte-level behavior when you need it, including a CP932X mode that brings JIS X 0213 support into CP932-compatible workflows. Its simple API is Jacode4e::convert(\$line, $OUTPUT_encoding, $INPUT_encoding, \%options), which returns a character count and accepts options to control fixed-record layouts, output shifting, SPACE and GETA replacement codes, override mappings, and reversible round-trip encoding. The module supports vendor and host encodings (CP932, CP932IBM, CP932NEC, CP00930, KEIS, JEF, JIPS, LetsJ), several UTF-8 variants, and fine-grained JIS/EUC/SJIS era handling, so it is useful when exchanging data with mainframes, preserving gaiji, or adding JIS X 0213 characters without a full system migration. The recent 2.13.6.23 release added era-aware 'sjis', 'euc', and 'jis' variants (1978/1983/1990/2000/2004), JIS X 0212 coverage as EUC code set 3 and ISO-2022-JP-1 output, many JIS output controls, and integrated the RoundTrip facility so reversible gaiji allocation is built into Jacode4e. If you work with legacy Japanese encodings or need deterministic, configurable conversions between PC, host, and JIS/Unicode repertoires, Jacode4e is likely relevant.

Mojolicious is a full‑featured, real‑time web framework for Perl that helps you build modern web apps and APIs quickly. It bundles a router with REST support, a built‑in nonblocking web server, Perl templates, content negotiation, session and cookie management, validators, a test framework, a static file server and a handy built‑in HTTP user agent, and it is easy to extend via plugins, helpers and lifecycle hooks. The framework favors sensible defaults and developer productivity while allowing deep customization for advanced use cases. Be sure to replace the default application secrets for signed cookies and sessions because the shipped default is intentionally insecure. If you want an actively maintained Perl framework that supports realtime features and minimal setup, Mojolicious is a strong, practical choice.

Config::INI::RefVars is a feature-rich INI file reader for Perl that extends the familiar INI format with variable references, include directives, line continuations, multiple assignment operators and both built-in and INI-level user-defined function calls, resolving all references at parse time and returning a plain Perl hash of sections and scalar values for easy programmatic access. It supports qualified cross-section references and a tocopy section or optional global mode for shared defaults, lets you access environment and Config values from the INI, and allows registering additional built-in functions when you construct the object. The parser implements operators like :=, += and ??=, detects recursion and syntax errors and throws exceptions on bad input. Recent maintenance releases cleaned up the distribution and in version 1.05 the tocopy/copy_vars handling was improved to allow variable names that begin with a left bracket, while earlier 1.00 added the function call and include features that make this module useful when you need more than basic INI parsing.

Net::DNS::ErrorReporter is a compact Perl module that implements DNS Error Reporting (RFC 9567) so a resolver can automatically notify a zone operator when it detects problems in a query response. You instantiate a reporter, hand it a Net::DNS::Packet containing a query response and an extended DNS error code, and it uses the EDNS0 agent domain advertised by the authoritative server to send an error-reporting query on your behalf. The report() call returns undef if the packet is invalid, missing the required EDNS0 option, or the report query fails, otherwise it returns the response packet from the resolver. The module provides readable constants for the full set of IANA extended DNS error codes and exposes its internal Net::DNS::Resolver for tweaking timeouts or transport settings. It is especially useful for operators and tools that need to integrate automated notification into workflows such as CDS/CDNSKEY/CSYNC scanning and other DNS monitoring tasks.

DBD::CSV is a DBI driver that lets you treat CSV files like a lightweight SQL database so you can run SELECT, INSERT, UPDATE and other SQL operations without a separate database server. It uses SQL::Statement as the SQL engine and Text::CSV_XS to parse and write rows, so you can query exported Excel or Access CSVs or simple flat-file datasets with familiar DBI calls. You point it at a directory or specific files and configure parsing and table options per connection or per table, including delimiter, quote and escape characters, record separator, encoding and NULL handling. Table creation only stores column names and not type or constraint metadata, and file locking relies on flock which may be unavailable on some older platforms. To use it install DBI plus DBD::File, SQL::Statement and Text::CSV_XS and then connect with a DSN like dbi:CSV: and a small set of attributes.

Mojolicious::Plugin::Fondation::Problem provides a simple $c->problem helper that unifies error handling for Fondation apps by returning RFC 9457 "application/problem+json" payloads for API requests and rendering a human-friendly HTML error page for browser requests. Callers can supply status, title, detail, type, errors and instance and the plugin defaults to status 500 with title "Internal Server Error" when omitted. It automatically detects API traffic via OpenAPI route metadata, URL paths beginning with /api/, or an Accept header that prefers JSON, and it is mode aware so development mode exposes full fields while production only emits status and title to avoid leaking internals. HTML responses use a problem.html.ep template and will pick up Fondation's Bootstrap layout if present. The plugin integrates with the Fondation family of Mojolicious plugins and depends on Mojolicious::Plugin::Fondation.

DateTime::Format::Intl is a Perl port of the JavaScript Intl.DateTimeFormat API that formats DateTime or DateTime::Lite objects with CLDR-driven, browser-like locale rules. You create a formatter with a BCP 47 locale tag and options such as dateStyle, timeStyle, individual components, timeZone, numberingSystem or hourCycle, then call format, formatRange, formatToParts or formatRangeToParts to get localized strings or tokenized parts for custom rendering. It relies on CLDR and related Perl modules to deliver culturally sensible defaults and interval-aware formatting, including time zone name variants and day period wording. The module aims to closely match web browser behavior, so it can feel quite feature rich, but only the Gregorian calendar is supported and some options are constrained by CLDR and the underlying libraries. Because object creation does lookups and pattern resolution you should cache formatter objects rather than recreate them for every date, and note it requires Perl 5.10.1 plus several non-core dependencies.

DBI is the standard, database‑independent database access layer for Perl that gives your scripts a consistent API for connecting to databases, preparing and executing SQL, binding parameters, fetching rows, and managing transactions while leaving engine‑specific work to driver modules (DBD::...). It is the go‑to foundation for any Perl code that talks to SQL databases and adds convenience helpers and features like safe quoting and placeholders, cached prepares and connections, detailed tracing and profiling, and metadata/catalog methods so you can write portable code without learning each database’s quirks. DBI is mature, widely used and actively maintained, and is primarily relevant if you write Perl that interacts with relational databases or build libraries that must support multiple backends. Recent releases have focused on security hardening and robustness, fixing parsing and buffer issues and tightening placeholder handling, and the project now warns that the next release will require perl‑5.12, so upgrade planning and using up‑to‑date DBD drivers is recommended.

Acrux is a lightweight Perl toolkit that provides common application building blocks such as flexible logging, file locking, a Damm check-digit digest, simple word parsing, date formatting and interactive prompt helpers, plus config and path utilities that complement Acme::Crux. It is aimed at Perl developers who want ready-made, well scoped helpers for command-line and server programs rather than a full framework. Recent updates include a switch of the default logging backend from syslog to STDERR with explicit targets for stdout, stderr and syslog and safer fallback behavior, the addition of Acrux::FileLock and Acrux::Digest::Damm, and a fix to Plugin::Log configuration handling. The project is maintained under the Artistic License 2.0.

Protobuf is a high-performance Perl binding for Google Protocol Buffers that uses the C upb library to give fast, memory-efficient serialization and parsing from Perl code. It exposes the familiar building blocks you expect from protobufs, such as DescriptorPool, Message classes and Arena memory management, and supports binary, JSON and text formats, well-known types, length-prefixed streaming, and generated Perl classes for your schemas. The implementation is designed to mirror the behavior of the official UPB-based Python extension so you get predictable interop and production-grade speed while staying in Perl. If you need compact, cross-language data interchange or efficient on-the-wire message handling from Perl, this module is relevant. Recent releases focus on portability and build hardening, with the 0.05 update improving Windows build and linking support and fixing several XS and test-suite issues to make installation and use more robust across platforms.

Module::Starter::Protobuf is a Module::Starter plugin that automates building a Perl CPAN distribution from proto3 Protocol Buffers schemas. It invokes protoc with the upb plugin to generate low level serialization classes and then scaffolds high level, idiomatic gRPC client wrappers using Moo and the Google::gRPC::Client stack, with an optional REST transport via Google::Cloud::REST::Client and Google::Auth for credentials. The plugin also emits a schema container module, injects necessary dependencies into Makefile.PL, and creates a basic integration test so you get a publishable client library quickly for Google Cloud or any service defined by .proto files. This is useful if you need to turn protobuf definitions into usable Perl clients without hand writing boilerplate, though the generated POD in this snapshot showed a few minor documentation formatting warnings that may need a quick manual fix.

Google::Cloud::Storage::V2 is a Perl client that provides high-performance access to the Google Cloud Storage V2 API over gRPC. It lets Perl applications interact with Google Cloud Storage for common tasks such as managing buckets and objects, and is instantiated with credentials from Google::Auth to authenticate requests. This module is aimed at developers who need fast, direct programmatic access to Cloud Storage from Perl and is released under the Apache 2.0 license.

Google::Cloud::SecretManager::V1 is a Perl client for the Google Cloud Secret Manager V1 API that talks to the service over a high-performance gRPC transport. It gives Perl applications a straightforward way to programmatically create, store, access and manage secrets and their versions using Google Cloud credentials. The module integrates with Google::Auth for authentication and accepts standard credential objects when you construct the client. It is distributed under the Apache 2.0 license and this entry marks the initial release.