CPANscan

Salus is a lightweight Perl toolkit for reading, writing and manipulating CSV files while optionally protecting them with an HMAC secret so you can detect tampering. You declare the column headers up front and then use a simple API to read protected or unprotected CSVs, add, update or delete rows, combine multiple CSVs by a key column, search and sort data, and run basic numeric aggregations like sum, mean, median and mode. It also offers helpers to stringify headers, diff files and work with rows either as arrays or hashes, making it handy when you need spreadsheet-style operations without a full database. The 0.10 release focuses on code hygiene by removing PAX headers and enabling strict and warnings.

Sys::RunAlways is a tiny, no-frills Perl helper that prevents multiple copies of the same script from running by locking the script's DATA filehandle when the module is loaded, letting your program continue only if it can acquire that lock. If the script has no DATA handle the module aborts with an error, if the lock is already held it exits silently with status zero, and if the lock is acquired it prints a startup message unless you pass the silent => 1 option to suppress that output. It is useful for simple cron jobs or lightweight daemons where you want an easy at-most-one-instance guard and depends only on core Fcntl, but you must include a DATA handle (for example via __DATA__ or __END__) for it to work. Be aware that symlinked copies of the same file will be treated as the same script and that editing a running script can release the lock and allow another instance to start. The module was updated over the years for adoption and the silent option, and the most recent 0.08 release is a small housekeeping update.

Sys::RunUntil is a tiny, zero-dependency Perl module that ensures a script runs no longer than a specified time. You activate it by loading the module with a runtime string such as "30mW" for 30 minutes of wallclock time or "30sC" for 30 seconds of CPU time, and you can combine units like "1H30M". If the script exceeds the limit the module will terminate it, which makes it handy for long-running batch jobs, cron tasks, test suites, and other resource-constrained runs. The module supports both wallclock and CPU limits and requires no extra libraries. Recent maintenance has kept the module lightweight and portable.

PerlIO::via::MD5 is a small PerlIO layer that makes it trivial to compute an MD5 checksum of a file by opening it with the :via(MD5) layer and reading from the handle, returning the digest instead of the file contents. It supports three output formats controlled by a class method: a 32‑character hexadecimal string, the raw 16‑byte binary digest, or a 22‑byte base64 MIME string. The layer is read‑only and stores the chosen format with each opened handle, and you change the default for subsequently opened files via the provided method because PerlIO does not allow passing parameters at open time. The module depends on Digest::MD5 and is useful when you want a simple, filehandle-style way to obtain MD5 checksums without writing explicit digesting loops.

PerlIO::Via::Base64 provides a PerlIO layer that transparently decodes Base64 when you read from a handle and encodes to Base64 when you write to one, so you can open files with via(PerlIO::Via::Base64) and treat MIME Base64 data like ordinary file I/O. It supports the usual MIME behavior of wrapping encoded output into 76-byte lines by default and exposes a class method eol to change the line-ending behavior or disable line breaks entirely. The layer is convenient for scripts that need to read or produce Base64-encoded files without calling encode/decode explicitly, but be aware that the current implementation reads or writes the entire file into memory before encoding or decoding, so it is not suitable for very large streams.

PerlIO::via::Rotate is a PerlIO layer you can attach to filehandles to transparently apply the classic rotational letter substitution (rotN) encoding and decoding, defaulting to rot13 but supporting any rotation from 0 to 26; you enable it by naming the rotation when loading the module or in your layer spec, for example <:via(rot13) for reading or >:via(rot14) for writing, and it will shift only ASCII letters while leaving other bytes alone. It is useful when you need to read or write files already encoded with rot-style ciphers without manually transforming data, and you can allow a single rotation, a list of rotations, or use the special ":all" keyword to permit all rotations. Internally the module acts as a front end that loads one of the PerlIO::via::rot0…rot26 helpers because PerlIO layers cannot take runtime parameters, but that detail does not change the simple usage model. The latest 0.11 release contains minor packaging maintenance including removal of PAX headers.

PerlIO::via::LineNumber is a lightweight PerlIO layer that transparently prefixes line numbers onto lines read from or written to a file handle, making it handy for quick debugging, printed listings, or simple text transforms; you enable it by opening a handle with :via(LineNumber) or by applying binmode and you configure the starting number, numeric format, and step size via class methods or as options to the module because PerlIO::via does not support passing parameters at open time. Defaults are line 1, format '%4d %s', and increment 1, and you can change the increment to produce BASIC-style numbering like 10, 20, 30. The module has no extra runtime dependencies and is intended as a small development tool rather than a production formatter. The recent maintenance release cleaned up packaging by removing PAX archive headers while keeping the interface stable.

Smaz is a tiny compression library optimized for very short strings, offering two easy functions, smaz_compress and smaz_decompress, so you can quickly shrink and restore short textual values. It is not a drop-in replacement for general-purpose compressors but it excels on small English phrases and common tokens, often cutting size by 40–50% on average and even compressing words like "the" down to a single byte, while still providing some benefit for HTML and URLs. This Perl module is a thin wrapper around Salvatore Sanfilippo’s Smaz algorithm, is lightweight and fast, and is useful when you need to reduce storage for keys, tags, short messages or other tiny text fields; recent updates focused on better test coverage and minor build/test housekeeping.

Game::Snake is a small Perl module that provides a playable clone of the classic Snake game using the raylib graphics library. It exposes a simple object-oriented interface so you can create a Game::Snake object and call run to start the game, and the distribution includes a ready-to-run snake.pl example. The module is useful as a fun demo, a learning resource for building simple games and handling input and rendering in Perl, or a starting point for extending a basic arcade-style game. Documentation is available via perldoc and the CPAN pages, and the 0.11 release is a minor maintenance update that removes PAX headers from the package.

Game::Floppy is a small Perl module that implements a Flappy Bird style game using the raylib graphics library, letting you create and run the game from Perl with a minimal API. You typically instantiate the game with Game::Floppy->new() and start it with ->run(), or run the included floppy.pl script to play the demo. It is useful if you want a lightweight, playable example of game programming in Perl, a quick demo for raylib Perl bindings, or a starting point for building simple 2D games. The module is released under the Artistic License 2.0 and requires raylib and its Perl bindings to be installed.

Mojo::DOM::Role::Restrict is a plugin for Mojo::DOM that lets you declaratively limit and transform HTML by supplying a specification of allowed tags and attributes. You describe rules per tag, use "*" as a wildcard, and control attributes with simple flags, regular expressions, or custom callbacks to accept, modify, or remove values. The role can remove or replace tags, mutate or prefix attributes, validate whether the current DOM matches the spec with valid, apply irreversible changes with restrict, and show what changed with diff using a configurable diff backend. It is useful when you need to sanitize or normalize HTML output in a controlled, programmable way without diving into the parser internals.

Ascii::Text::Image is a small Perl module that renders ASCII or banner-style text into bitmap image files. It builds on Ascii::Text and uses an Imager TrueType font to draw text with configurable font, color and padding, and you create images simply by instantiating the object with options like imager_font and padding then calling it with the text and an output filename. This makes it handy for generating programmatic headers, banners, or label graphics from scripts and web apps without manually composing images. The module is available on CPAN, documented via perldoc, and released as version 0.06 under the Artistic License 2.0.

Ascii::Text is a lightweight Perl module for turning plain strings into styled ASCII-art banners that you can print to the terminal or write to a file. You create an object, pick a font and styling such as color, alignment, padding and maximum line width, then call render to print or stringify to get the output as text. The module adapts to your terminal width by default, supports custom ANSI color maps, lets you override inter-word spacing, and can return the generated lines to your program for further processing. It is useful for adding readable, attention-grabbing headings to command line tools, scripts, logs, or text files without needing to handcraft large ASCII layouts.

Module::Generate::YAML provides a single exported function, generate, that reads a human‑readable YAML specification and produces a Perl module or distribution skeleton for you, so you can describe classes, methods, accessors, POD, metadata and small code blocks in YAML and have the module files generated automatically. It is handy when you want to script or template module creation rather than handcraft files, and it can be invoked from the command line for quick scaffolding. The recent 1.01 update removed PAX headers from generated archives to produce cleaner package metadata.

Module::Generate::Hash is a small utility that builds Perl distributions and classes from a simple hash-based specification, exporting a single function named generate that accepts a hash describing the distribution name, author, version and the classes to create. You provide a declarative structure for each class including abstract text, package variables, begin blocks, accessors and subroutines with code references, POD and examples, and the module generates the corresponding module scaffolding for you. It is useful for authors, tooling and tests that need to produce multiple modules or boilerplate programmatically and saves time compared with hand-writing repetitive code.

Module::Generate is a Perl scaffolding tool that programmatically builds distributions, packages and their test files so you do not have to hand-write repetitive boilerplate. Via a fluent API you declare the distribution name, author and version, add classes and then define constructors, accessors, methods, POD with examples, tests and compile-phase blocks, and even create reusable macros and custom keywords to inject shared code across classes. It writes out ready-to-run module files and test skeletons to speed up module development and release preparation, so it is best suited to Perl authors and maintainers rather than end users of a library. The recent 1.03 update removes generated links to AnnoCPAN and CPAN Rating and fixes POD versioning so generated documentation reflects the module version.

Cpanel::JSON::XS is a fast, C-implemented JSON encoder/decoder for Perl that prioritizes correctness and full Unicode handling while offering a rich set of configuration options for common needs like pretty printing, ASCII/latin1/binary output, canonical key sorting, bignum support, and controlled handling of blessed objects. It preserves round-trip fidelity for JSON-representable data, supports incremental parsing and BOM detection, is thread-safe, and is the actively maintained cPanel fork with a public issue tracker so bugs get fixed promptly. It integrates cleanly with JSON::MaybeXS so you can get its speed transparently and offers defensive defaults and limits to avoid resource or security issues, though note the allow_nonref behavior was changed to permissive by default in a recent release and can be disabled if you require strict top-level array/object enforcement. The very latest updates include a canonical sort fix that now compares keys by UTF-16 code units to match RFC 8785 and a quadmath-related float formatting fix to avoid dropping “.0” on high-precision platforms, plus many practical bug and security fixes across platforms and Perl versions.

Net::DNS is a mature collection of Perl modules that give you full DNS resolver functionality beyond the simple gethostbyname/gethostbyaddr calls, letting Perl programs perform lookups, zone transfers, asynchronous queries, and dynamic DNS updates. It models DNS concepts with Resolver objects for query state, Packet/Header/Question objects for responses, and RR objects for resource records, and it provides convenient helpers such as rr() and mx() for common lookups, rrsort() for ordering records, and builders for update prerequisites and add/delete operations. The module also includes utilities for managing zone serial numbers and supports AXFR and background queries, so it is a good fit if you need to script DNS administration or implement protocol-aware DNS clients in Perl. Expect to be comfortable with basic DNS concepts and zone file formats to use it effectively. The project is actively maintained at NLnet Labs and is widely used, but the authors note that Net::DNS can be relatively slow compared with some lightweight alternatives.

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.

Google::Cloud::SQL::V1 is a Perl client library for the Google Cloud SQL Admin API v1 that lets you manage Cloud SQL resources from Perl programs. It uses a high-performance gRPC transport for efficient remote calls and pairs with Google::Auth to handle credentials, so you can construct a client with an auth object and script administrative tasks like creating or configuring instances, scheduling backups, and managing users. The module is aimed at developers who want to automate Cloud SQL operations from Perl with low-latency RPCs. This is the initial 0.01 release and the library is provided under the Apache 2.0 license.

Google::Cloud::PubSub::V1 is a Perl client library for the Google Cloud Pub/Sub v1 API that communicates over a high-performance gRPC transport. It provides a convenient way for Perl applications to publish and receive messages and to create and manage topics and subscriptions while using Google authentication modules such as Google::Auth. If you need native Perl access to Google Cloud messaging for event-driven systems, streaming pipelines, or background job coordination this module gives you the API surface and transport performance to integrate Pub/Sub into your app. The library is distributed under the Apache 2.0 license.

Google::Cloud::PrivateCA::V1 is a Perl client for Google Cloud's Certificate Authority Service that lets your code create and manage private certificate authorities and issued certificates through the V1 API using a high-performance gRPC transport. It integrates with Google::Auth for obtaining credentials so you can programmatically provision CAs, issue and revoke certificates, and automate private PKI tasks inside Google Cloud from Perl applications. The module is distributed under the Apache 2.0 license and is useful if you need to embed certificate lifecycle operations into scripts or services that interact with Google Cloud. This is the initial release of the client.

Google::Cloud::NetworkServices::V1 is a Perl client library for the Google Cloud Network Services V1 Secure Web Proxy API that lets Perl applications authenticate with Google::Auth and manage secure web proxy and related network resources programmatically. It talks to Google Cloud over a high-performance gRPC transport so you can automate creation, configuration, and management of proxy endpoints and policies from Perl code. The module is suitable for developers who need to integrate Google Cloud network service operations into scripts or applications and is released under the Apache 2.0 license; this listing is the initial 0.01 release.

Google::Cloud::NetworkSecurity::V1 is a Perl client library that lets Perl applications call the Google Cloud Network Security V1 API over a high-performance gRPC transport. It integrates with Google::Auth for credentials so your scripts can authenticate to Google Cloud and manage network security configuration and policies programmatically. Use this module when you need to control Network Security features from Perl code rather than using the web console or REST calls. The module is distributed under the Apache 2.0 license.

Google::Cloud::Metastore::V1 is a Perl client library that lets Perl applications talk to the Google Cloud Dataproc Metastore V1 service over a high-performance gRPC transport. It provides a straightforward way to authenticate with Google::Auth and programmatically create, configure, and manage Metastore services and their metadata for Hive and other big data workloads on Google Cloud. The module is aimed at developers who need to integrate Dataproc Metastore operations into Perl scripts or applications and is distributed under the Apache 2.0 license. This package was first released as version 0.01 on Jul 13, 2026.

Google::Cloud::IAM::V1 is a Perl client library that gives your Perl apps programmatic access to Google Cloud Identity and Access Management (IAM) v1 using a high-performance gRPC transport. It is designed for managing IAM concepts like roles, policies, service accounts and permissions from Perl code and works with Google::Auth to obtain credentials and authenticate calls. Use it when you need to perform IAM operations from a Perl service or script and prefer a gRPC-backed client for efficiency and parity with the Cloud IAM API.

Google::Cloud::Dataproc::V1 is a Perl client for the Google Cloud Dataproc V1 API that communicates over a high-performance gRPC transport, making it suitable for programs that need efficient, programmatic access to Dataproc from Perl. The module integrates with Google::Auth for authentication and provides a straightforward way to create and manage Dataproc resources such as clusters and jobs and to submit and monitor work from Perl code. It is licensed under Apache 2.0 and this listing is the initial distribution release.