CPANscan

mb.pm is a small "modulino" that lets you write Perl scripts using legacy multibyte encodings (Big5, Big5-HKSCS, EUC-JP, GB18030, GBK, Shift_JIS/CP932, UHC, UTF‑8 and WTF‑8) by transpiling your source into an octet-oriented Perl program before running it. It detects or accepts a chosen encoding and rewrites literals, regular expressions and string operations so multibyte codepoints behave sensibly while leaving traditional byte-oriented built-ins unchanged, and it supplies an mb:: namespace (mb::length, mb::substr, mb::tr, mb::chr, mb::ord, mb::do/mb::eval/mb::require/mb::use, etc.) for codepoint-aware operations. The tool handles tricky issues like multibyte anchoring and escaping of bytes that would otherwise act as Perl metacharacters, supports many platforms and very old Perls (back to 5.005_03), and is aimed at keeping "easy jobs easy" for people maintaining MBCS-era scripts. You do need to run scripts through the modulino (perl mb.pm script.pl) and it generates a translated .oo.pl file, and there are known limitations such as incomplete Unicode property support, no named codepoints, ASCII-only casing helpers, some regex/lookbehind and Windows chdir edge cases, and a few other intentional omissions; these tradeoffs are documented by the author. Recent updates added support for finally blocks and related syntax and smaller language fixes including support for the ^^ logical xor operator and raised regex limits on modern Perls, making the transpiler more compatible with contemporary Perl syntax.

Rex::LibSSH is a connection backend for the Rex automation framework that uses Net::LibSSH, the XS binding to libssh, to provide SSH, command execution and file operations without requiring an SFTP subsystem. It implements Rex connection, exec, fs and file interfaces and performs file operations over plain SSH exec channels, making it a good fit for minimal containers, embedded systems or any host that lacks SFTP support and would otherwise fail. Enable it by setting connection => 'LibSSH' in your Rexfile and authenticate with public keys via Rex::Config or by passing keys to Rex::connect. Host key checking is disabled by default to avoid blocking non-interactive deploys and can be enabled with strict_hostkeycheck.

File::StatX exposes the Linux statx system call to Perl so you can retrieve much richer and more modern file metadata than Perl's built-in stat provides, including creation time, mount and subvolume identifiers, direct-I/O alignment and atomic-write limits, device major/minor numbers, filesystem attributes like immutable, encrypted, verity and DAX, and block allocation details. You call statx, statxat or fstatx with a mask and flags to request only the fields you need and get back a File::StatX object with accessor methods such as size, mtime, btime, nlink, dio_mem_align and others; fields that your kernel or filesystem does not support will simply be absent or zero. This module is useful for system utilities, backup and verification tools, filesystem-aware applications and anyone needing precise performance and integrity-related file information on Linux. Note that some capabilities depend on kernel and filesystem support and may not be available everywhere. The recent 0.005 update fixes detection of available attributes and corrects a define used in optional methods.

Tlaloc is a small, playful utility for Perl that lets you attach an invisible "wetness" meter to scalars and to tied arrays or hashes so their wetness decays each time the value is read. You control wetness with simple functions like wet and drench, inspect it with wetness, is_wet and is_dry, and tune how fast it evaporates with evap_rate. By default a wet or drenched scalar loses a fixed amount on every access so the underlying string value never changes while the hidden metadata counts down. For arrays and hashes you can either track wetness only when you explicitly query it or use wet_tie to make element access and other operations cause passive evaporation. Useful for toy state, TTL-like behavior tied to reads, or adding ephemeral metadata to variables, Tlaloc is easy to use but has a few caveats: do not pass literals, magic is per-SV so assignments do not copy wetness, and it is not thread safe. This is an early stage module with only an initial release in its change log.

Apophis is a compact, high-performance content-addressable storage library for Perl that produces deterministic UUID v5 identifiers for blob content using the Horus RFC 9562 library. It guarantees identical content maps to the same UUID while different namespaces yield distinct UUIDs, making deduplication and logical partitioning straightforward. Objects are stored in a two-level hex-sharded directory layout for scalable filesystem performance, writes are atomic via temporary files and rename, and file identification is streamed in fixed-size chunks so large files use constant memory. The API is minimal and pragmatic: identify content or files, store and fetch by UUID, verify integrity, remove items, and run bulk operations like store_many and find_missing, with optional per-object metadata. The core is implemented in C with an XS Perl wrapper so you get C-level speed from simple Perl calls, making Apophis a good fit when you need deterministic, namespace-aware CAS with efficient on-disk layout and atomic semantics.

Colouring::In::XS is a fast, XS-backed Perl module for creating, converting and manipulating colors in a variety of common formats. You can instantiate colors from hex, RGB(A), HSL(A) or arrays and convert them to hex, rgb/rgba, hsl, hsv or Terminal::ANSIColor strings, with automatic CSS-friendly stringification. It also provides color operations such as mix, lighten, darken, tint, shade, saturate, desaturate, greyscale and opacity control via fade/fadein/fadeout, plus a validator for input colors. The implementation in XS makes it much faster than a pure-Perl equivalent, so it is a good fit for web or terminal applications and scripts that need reliable color math and high performance.

Horus is an ultra-fast XS UUID/GUID generator for Perl that implements all RFC 9562 versions (v1–v8) plus NIL and MAX, and offers ten output formats including hyphenated string, hex, braces, URN, base64, base32, Crockford base32 and raw binary. It is a pure XS module with no external C library dependencies and is optimized for high throughput and low Perl/C boundary overhead, with bulk generation, an object interface, and support for deterministic namespace UUIDs (v3 and v5), time and monotonic variants (v1, v6, v7), random v4, and custom v8 payloads. The module also includes utilities for validation, parsing, conversion, comparison and extracting timestamps, making it a good choice when you need fast, flexible UUID generation for high‑performance services, databases or distributed systems.

Litavis is a high‑performance CSS preprocessor and compiler for Perl that runs its engine in C via XS, designed to replace the older Crayon tool while keeping compatibility where useful. It accepts enhanced CSS with nested selectors, parent references, variables, mixins, and map variables and resolves colour functions like lighten, darken, mix and fade at compile time, then emits standard CSS either minified or pretty printed. The compiler preserves cascade rules and offers cascade‑aware deduplication with conservative and aggressive modes so you can balance safety and output size, and it supports file and directory parsing, import hoisting, hex shorthand, comment stripping and passthrough of CSS custom properties and calc expressions. Compilation is non‑destructive so you can call compile multiple times and reset state between projects, and the module also installs reusable C header files for downstream XS modules that want to embed the same engine. Use Litavis if you need a fast, spec conscious CSS build step in Perl or want a C‑level library for CSS preprocessing.

CPANSA::DB is a lightweight, data-only Perl module that provides the CPAN Security Advisory reports as a ready-to-use Perl data structure, primarily consumed by CPAN::Audit but available to any tool that needs a canonical list of CPAN security advisories. The module exposes a single subroutine, db, which returns a hash reference of the advisory records, and a JSON equivalent of the same dataset is also distributed for non-Perl consumers. Releases are signed with GPG and published on GitHub with attestations so you can verify the archive came from the official repository. The project is actively maintained with frequent CVE and report updates and recent work has reduced the database size by switching to a terser internal format, making it easier to bundle into auditing and deployment workflows.

Eshu is a fast, XS-powered tool for normalizing leading indentation in C, Perl and XS source files by tracking nesting and rewriting only the whitespace at the start of each line while leaving the rest of the code untouched. It understands language-specific constructs that affect indentation including C strings, comments and preprocessor directives, Perl heredocs, regexes and pod sections, and XS dual-mode files with XSUB boundaries and labels. The module exposes simple entry points to fix C, Perl or XS text or to auto-dispatch by language, and it can detect language from a filename. You can choose tabs or spaces and set the indentation width, and there is an option to indent preprocessor directives when desired. Eshu is implemented in C for single-pass speed and ships with a command line utility for in-place fixing, diffs, CI checks or stdin/stdout processing, making it a practical choice for keeping mixed-language codebases consistently indented.

Daje::Tools::JWT is a small helper module for working with JSON Web Tokens in Perl that wraps Mojo::JWT to make encoding and decoding straightforward. It provides convenience methods to fetch the keys used for company-wide and company-user tokens and to encode and decode JWTs so your application can issue and verify tokens without dealing with lower level details. The module is lightweight and intended for projects that already use Mojo::JWT and need simple JWT utilities; it depends on Mojo::JWT, Data::Dumper, and Mojo::Base. This is the initial 0.25 release.

Daje::Database::Migrator is a lightweight migration plugin for the Daje::Workflow ecosystem that automates applying database schema changes. You pass it a list of migration entries that point to either a Perl migration class or a SQL file along with a pg database handle, and calling migrate() runs those updates for you. It is minimal by design, depends on Mojo::Loader and Perl v5.40, and is useful when you want a simple way to manage incremental schema changes inside a Daje workflow. Recent updates add basic exception handling to make migration failures clearer and easier to debug.

Daje is a minimal Mojolicious web server module that provides a simple application skeleton for serving "Daje" functionality and includes a startup method that runs when the server boots. It relies on Mojo::Pg for PostgreSQL integration and uses Mojo::Base and Cwd, so it is best suited for developers who want a lightweight Mojolicious service with built-in database wiring rather than a full-featured framework. The module is maintained by janeskil1525 and is released under the same license as Perl. The recent 0.10 release restored tests and marks an initial Beta 1 stabilization.

Daje::Database::Model is the small core of the Daje project's database layer, providing the shared model classes and a common base for database-backed objects so other Daje components can define and reuse consistent behavior for their data entities. It is aimed at developers building or maintaining Daje applications who want a centralized place for model defaults and basic model functionality. The module requires Perl v5.40 and experimental features and is released under the same terms as Perl. Recent updates added a base class for defaults and fixed a bug.

Daje::Plugin::Apploader is a startup helper for the Daje web server that reads a configuration structure and automatically loads plugins, helpers, routes and namespaces when the server boots. It can optionally check CPAN and install or update missing Perl modules for you, removing the need for manual dependency management. The plugin expects a nested load_ables configuration describing namespaces, plugin entries with options, helpers and route mappings and exposes a register method the application calls to perform the loading. If you run a Daje-based application and want declarative startup wiring plus optional automatic module installation, this module streamlines that process and requires Perl v5.42 along with Mojo::Loader, CPAN and the other listed dependencies.

Daje::Plugin::Workflow is a Mojolicious plugin that connects your web app to the Daje::Workflow framework so you can load, manage and execute workflows from inside a Mojolicious application. It expects a simple configuration block that points to your workflow files and loader type and it relies on the Daje::Workflow, Daje::Workflow::Loader, Daje::Workflow::Database and Daje::Database::Migrator components to provide runtime and persistence. Use it when you need to expose workflow execution as part of a web service or to centralize workflow management within a Daje-based project. The module targets Perl v5.40 and provides a register method for startup integration. Recent updates include several bug fixes, improved logging and documentation, and a URL change for execution to /workflow/api/execute.

Daje::Plugin::Mail is a small Mojolicious plugin that wires mail-related helpers, routes and database migration support into a Mojolicious application so you can add mail functionality with minimal setup. Install it into your app with $app->plugin('Mail') or plugin 'Mail' in Mojolicious::Lite and rely on its bundled components Daje::Plugin::Mail::Helpers, Daje::Plugin::Mail::Routes and Daje::Database::Migrator to provide the common plumbing for handling mail tasks inside the Mojolicious framework. The module requires Perl v5.42 and Mojo::Base and is released under the same terms as Perl. This is the initial 0.01 release published on 2026-03-29.

Daje::Workflow is a lightweight Perl workflow engine that models processes as named states and transitions so you can describe business logic as a sequence of actions that move an object from one state to the next. It integrates with companion loader and database modules to persist workflow instances, uses a simple context hash to pass data into activities, and exposes methods like process and save_workflow to run actions and store state. The module is intentionally minimal and easy to extend with your own activities, checks and model classes; recent releases added activity pre and post checks and improved the mandatory-attribute validation to accept a model class as an argument. If you want a compact, database-backed state machine for coordinating application flow in Perl without a heavy framework, Daje::Workflow is a practical starting point.

Daje::Plugin::Languages is a lightweight plugin for the Mojolicious web framework that wires language-related features into your application so you can quickly add language data, authority handling, helpers and routes without wiring everything by hand. You enable it with plugin 'Languages' in a Mojolicious::Lite app or $self->plugin('Languages') in a full Mojolicious app, and it brings together supporting components for database migrations, language and authority management, reusable helper routines and route definitions. The module is intended as an integration point rather than a full standalone framework, depends on Daje::Database::Migrator and several Daje::Plugin::Languages::* components, and is released as its initial version.

Daje::Plugin::Authorities is a small Mojolicious plugin that adds an authorities subsystem to a Mojolicious application, bundling route definitions and helper code to simplify handling authority or access-related functionality. You install it into your app with $self->plugin('Authorities') or plugin 'Authorities' in Mojolicious::Lite and it relies on companion modules Daje::Database::Migrator and the Daje::Plugin::Authorities::Authorities, ::Helpers and ::Routes components so you get database migration support plus ready-made helpers and routes out of the box. It is intended for web developers who want a drop-in authorities layer for their Mojolicious projects and is currently released as the initial 0.01 version.

Daje::Plugin::Users is a lightweight Mojolicious plugin that provides a ready-made layer for user-related functionality in web applications, bundling route definitions, helper routines and database migration support by delegating to Daje::Plugin::Users::Routes, Daje::Plugin::Users::Helpers and Daje::Database::Migrator. You enable it with a single call, plugin 'Users' in Mojolicious::Lite or $self->plugin('Users') in a full Mojolicious app, and it requires Perl v5.42 and Mojo::Base. The module is intended to simplify adding common user management features to Daje-based projects and this listing represents the original 0.01 release.

Daje::Plugin::Companies is a small Mojolicious plugin that wires company-focused routes and helper routines into a web application so you can quickly add company-related features without plumbing them together yourself. It delegates database migrations to Daje::Database::Migrator and splits functionality into companion modules Daje::Plugin::Companies::Helpers and Daje::Plugin::Companies::Routes, and it is installed with $app->plugin('Companies') in a full Mojolicious app or plugin 'Companies' in Mojolicious::Lite. The module requires Perl v5.42 and Mojo::Base, and its initial public release is version 0.01 published 2026-03-29.

Daje::Plugin::Kanban is a small Mojolicious plugin that wires Kanban-style board features into a Mojolicious application, letting you enable routes, helpers, permissions and multilingual support for kanban workflows with a single plugin registration. It delegates functionality to companion modules for database migrations, language handling, authority management, helper utilities and route definitions, so it is most useful to Perl web developers already using Mojolicious who want an out-of-the-box way to add kanban boards and related UI and access controls without building the plumbing themselves. The module targets Mojolicious v5.42 and above and is an initial 0.01 release, so expect a compact, opinionated integration that relies on the Daje::* components listed in the requirements.

Dist::Zilla::PluginBundle::DBIO is a ready-made Dist::Zilla configuration that standardizes packaging and release tasks for the DBIO family of Perl distributions. It saves maintainers from repetitive setup by providing sensible defaults so driver modules usually need no configuration, with versions read from git tags and a custom dual copyright notice emitted in POD. For the DBIO core you set core = 1 to switch to VersionFromMainModule and a different MakeMaker setup, and for code derived from DBIx::Class you set heritage = 1 to add DBIx::Class copyright attribution into generated POD. The bundle includes Pod::Weaver collectors for =attr and =method, integrates NextRelease to automate Changes file management, supports self-bootstrapping via Bootstrap::lib, and expects extra plugins like MetaNoIndex and MetaResources to be added after the bundle when required.

Rex::Rancher is a Rex plugin that automates zero-touch deployment of Rancher Kubernetes distributions RKE2 and K3s, taking you from raw Linux node prep to a running cluster with Cilium CNI and optional NVIDIA GPU support. It handles hostname, timezone, NTP, kernel module and sysctl tuning, swap disabling, control-plane or agent install, kubeconfig retrieval and patching, API readiness checks, and deployment of the NVIDIA device plugin when Rex::GPU is available, all while performing Kubernetes API actions locally via Kubernetes::REST so you do not need kubectl on the remote hosts. The module supports SFTP-less hosts via Rex::LibSSH, can write registry mirror config, and provides idempotent Cilium installation so tasks are safe to re-run. This initial release provides a unified server and agent interface and a full automated pipeline for bringing up GPU and non-GPU Rancher clusters, useful for operators who want scripted, repeatable cluster provisioning.

Rex::GPU is a Rex extension that makes it easy to detect GPU hardware on remote machines and to automate the software stack needed to expose NVIDIA GPUs to Kubernetes workloads. It scans PCI devices to find real NVIDIA and AMD cards, skips virtual GPUs, and then optionally installs NVIDIA drivers via DKMS, blacklists the nouveau driver, handles an optional reboot, installs the NVIDIA container toolkit, writes a CDI device spec for Kubernetes, and injects the NVIDIA runtime into containerd configurations for RKE2, K3s, or standalone containerd. AMD cards are detected but not yet supported. The module targets common Linux distributions and has been tested on Hetzner bare-metal servers, and it requires a LibSSH or SFTP-capable Rex connection. Use this module if you want a single Rex call to make a node GPU-ready for Kubernetes without hand-editing drivers, toolkit settings, or containerd configuration.

List::Util::Find is a small, zero‑dependency collection of exportable helpers for quickly testing whether numeric or string values appear in a list, offering single‑needle checks like hasnum and hasstr, multi‑needle variants such as hasallnums and hasanystrs, and complementary lacks* functions for absence tests. The routines short‑circuit for speed and handle undef and nonnumeric scalars carefully to avoid false matches, so hasnum will not treat undef or nonnumeric values as equal to a numeric needle and hasstr will not treat undef as an empty string. It is handy when you want concise, reliable presence or absence checks without loading extra modules and is provided as an experimental utility by the author.

Net::LibSSH is a lightweight Perl XS binding to the libssh C library that gives you direct SSH client capabilities without forcing an SFTP dependency on the remote host. It is geared toward automation tasks where remote file operations can be done over exec channels rather than requiring an SFTP subsystem. You configure a session with simple options like host, port and user, authenticate with password, public key or agent, open channels to run commands and capture output, and optionally open an SFTP handle that returns undef if the server does not support SFTP. Note that the module is not thread-safe and does not support fork so use one connection per process. The initial 0.001 release provides the core session and channel APIs along with a basic SFTP stat method.

Alien::libssh is an "Alien" distribution that makes the libssh C library easy to use from Perl by locating or building the library and exposing the compiler and linker flags other CPAN modules need. It first tries to find a system libssh via pkg-config and if none is available it downloads and compiles libssh from source using CMake, then provides cflags and libs through the Alien::Base API so modules can call Alien::libssh->cflags and Alien::libssh->libs when building. This is handy for Perl modules that depend on libssh, such as Net::LibSSH, because it removes the manual step of installing the library and standardizes how the build finds and links it.