CPANscan

Tk::DocumentTree is a Perl/Tk megawidget that provides a simple file or document browser by combining a label with an ITree widget and automatically building a folder hierarchy as you add entries. It shows the common path for all entries in the label, supports entries marked as regular files or as untracked items, and uses icons to indicate file, folder and modified/saved status with customizable callbacks for supplying icons and handling selection. The widget exposes convenient methods to add, delete, select and reveal entries, mark entries modified or saved, expand or collapse the tree, and retrieve lists of tracked or untracked files. It accepts most ITree options but reserves a few (for example -itemtype, -browsecmd, -separator, -selectmode and -exportselection) and ships with sensible default icons and a right‑click context menu that you can customize. This module is a good fit for Perl/Tk applications that need an integrated, editable document or project tree without building the widget from scratch.

DBIO::PostgreSQL::EV provides real non‑blocking PostgreSQL access for the DBIO framework by wiring DBIO to EV::Pg and libpq's async protocol, delivering async select/insert/update/delete operations, transactions, pipelining, LISTEN/NOTIFY, COPY IN, deploy_async and an async-aware connection pool while keeping normal synchronous DBI behaviour intact. The distribution itself is mainly a marker that you load into your schema to enable the "ev" async backend and the actual asynchronous implementation lives in DBIO::PostgreSQL::EV::Storage, with async mode enabled explicitly per connection using { async => 'ev' } at connect time. It integrates with the EV event loop and therefore works with AnyEvent, IO::Async (via EV) and Mojolicious, and when not opted into async the code falls back to the documented sync or forked fallback paths so existing code keeps working. Recent releases clarified the per‑connection opt‑in, renamed the distribution and namespaces to reflect the EV driver, and consolidated the storage on the core async machinery while fixing pooling, transaction and COPY race issues for more robust live use.

DBIO::PostgreSQL::PostGIS adds first-class PostGIS support to DBIO::PostgreSQL result classes so your spatial columns behave like native objects instead of raw text. Columns declared as geometry or geography are automatically inflated to lightweight Geometry objects on read and converted back to EWKT for writes. The module also injects spatial query helpers into resultsets for common operations such as distance searches, nearest neighbor ordering and standard spatial predicates, and it provides schema-level helpers like ensure_postgis and postgis_version for managing the extension. If you use DBIO with a PostGIS-enabled database this saves you from manual WKT/EWKT handling and makes spatial queries feel like ordinary resultset methods. Recent releases make PostGIS a registered storage layer instead of a storage_type override and improve error handling so missing-extension checks and internal parse errors now throw DBIO::Exception with clearer messages.

DBIO::Oracle is a lightweight adapter that makes DBIO talk to Oracle databases by automatically wiring your schema to the Oracle-specific storage and SQL dialect when you connect. Instead of changing your application logic this module simply ensures DBIO uses DBIO::Oracle::Storage (the -ora shortcut does this for you) and it includes sensible Oracle behaviors such as sequence-based auto-increment, LOB binding, RETURNING support, ROWNUM limit/offset handling, and a pre-9.0 fallback for non-ANSI joins. It is not a full ORM rewrite but the canonical way to run DBIO against Oracle engines and to pick up the complementary components for SQL generation, introspection, DDL and deployment. Recent fixes make identifier quoting safer by leaving Oracle pseudo-columns like LEVEL and ROWNUM unquoted to avoid ORA-00904, correct LOB type detection for bindings, and now require DBD::Oracle as a hard dependency so you get a working Oracle driver at install time.

DBIO::MySQL::EV provides non-blocking MySQL and MariaDB storage for the DBIO framework by talking directly to the database via EV::MariaDB instead of DBI, so queries return Future objects and you can run true async operations from an EV-based event loop. It is opt-in per connection by passing { async => 'ev' } to Schema->connect and is installed as a schema component so your existing DBIO resultset calls gain *_async variants that pipeline automatically at the wire level and use prepared statements for bound queries, while the synchronous methods remain available but will block the event loop. The module handles transactions, connection pooling with per-transaction pinning, and adapts INSERTs to MySQL by assembling returned-column hashrefs from LAST_INSERT_ID(), and it works with EV directly or with AnyEvent, IO::Async via Loop::EV, or Mojolicious. Recent releases refactor the storage into a thin transport over DBIO::Storage::Async for a smaller, shared core implementation and fix several production issues such as connection readiness, stale bind handling, and pooled-connection bugs, making the EV backend more robust and maintainable.

DBIO::PostgreSQL::Age adds Apache AGE graph database features to DBIO::PostgreSQL so you can manage named graphs and run openCypher queries from the DBIO stack. It installs a storage layer that composes over the existing PostgreSQL driver, so graph capabilities stack cleanly with other extensions and work on async transports, and you enable AGE on each connection with the provided load_age on_connect callback. The module exposes graph lifecycle operations like create_graph and drop_graph and a cypher() method to execute parameterized Cypher and return decoded results, with a new decode_agtype helper and an auto_decode option to turn AGE agtype cells into native Perl structures. The recent release makes AGE a true composable layer instead of hijacking the Pg driver, fixes a registration bug that could affect plain DBI connections, improves async dispatch, and standardizes connection replay for LOAD 'age' and search_path setup so the feature is safer and more interoperable.

DBIO::MSSQL is a tiny DBIO subclass that makes working with Microsoft SQL Server easy by automatically wiring your schema to the DBIO::MSSQL::Storage backend when you connect, so you can just "use DBIO 'Schema', -ms" and get MSSQL-aware storage, SQL generation and schema-management behavior without hand‑wiring the driver. It is the entry point for the MSSQL features in the DBIO family, including native DDL/introspection, schema diffs and deploys, SQL dialect tweaks for LIMIT/OFFSET and identity/GUID handling, and a Sybase/FreeTDS compatibility path when needed. If you use DBD::ODBC the recent patch adds a dedicated DBIO::MSSQL::Storage::ODBC class and fixes a schema-diff bug that could abort when a removed table and one of its indexes were dropped in the same operation, while also correcting FreeTDS version handling. Use this module when your application uses the DBIO ORM and your database is Microsoft SQL Server, otherwise you do not need it.

DBIO::GraphQL automatically builds an executable GraphQL schema from a connected DBIO::Schema by introspecting your tables and exposing columns as typed scalar fields, relationships as object or list fields, root Query operations for single lookups and plural allXs queries with nested per-column filters, ordering, offset and cursor pagination, and root Mutations for createX, updateX and deleteX. It supports composite primary keys and maps common SQL types to GraphQL Int, Float, Boolean, or String while translating DBIO search-condition syntax into typed filter inputs with logical AND/OR. Mutations surface database errors as GraphQL errors and delete returns false when a row is not found. Known limitations are that relationship fields are unfiltered, mutations accept only scalar column values and updates are full-row, custom scalars and subscriptions are not generated, and cursor pagination only advances correctly when ordering by the primary key. The to_graphql method returns a GraphQL::Schema plus the original DBIO schema as context so you can call GraphQL::Execution::execute directly. A recent release fixed a security issue by validating orderBy.field against the source columns to prevent SQL injection and improved error handling for unknown columns.

DBIO::Forked is a lightweight, dependency-free adapter that turns any synchronous DBIO/DBI driver into an asynchronous one by running queries in short-lived forked children and streaming results back to the parent over a pipe. You enable it per connection with { async => 'forked' } and the connection immediately returns a DBIO::Forked::Future so your main program can continue while the child does the blocking work. It requires only core Perl functions and modules so it works with drivers that lack native async bindings such as Oracle, SQLite, DB2, and Sybase, and it does not pull in an event loop or extra client libraries. Transactions are handled by running an entire txn_do_async block inside a single child process, so the block is non-blocking to the parent but individual statements inside the transaction are not interleaved with an event loop and you cannot issue per-statement async calls on a pinned transaction. Results and transaction returns must be Storable-serializable and nested async calls inside a transaction body are not supported. This is the first release, providing a generic, fork-based async storage backend that complements DBIO::Async for drivers that will never get native async clients.

DBIO::Firebird is a tiny DBIO schema component that makes DBIO-based applications talk to Firebird and InterBase databases by automatically selecting DBIO::Firebird::Storage when you connect. Load it into your schema or use the provided "use DBIO 'Schema', -fb" shortcut and your DBIO->connect calls will use the Firebird/InterBase storage implementation without extra wiring. It is aimed at developers who use DBIO as their ORM and need native Firebird/InterBase support via DBD::Firebird, including introspection, DDL generation, and diff/deploy features provided by the companion storage modules. In the recent 0.900001 release a full-schema sync bug was fixed so that a DROP INDEX will no longer conflict with a concurrent DROP TABLE during apply/upgrade, and the distribution now requires DBD::Firebird as a hard dependency.

DBIO::DuckDB is a DBIO schema component that adds first-class DuckDB support to DBIO-based applications by forcing the storage class to DBIO::DuckDB::Storage and using DBD::DuckDB to talk to an embedded DuckDB instance. It preserves the familiar DBI/ORM behavior for transactions, binds, cursors and result sets while exposing DuckDB-native capabilities such as the Appender API for fast bulk inserts, an Arrow-oriented columnar fetch path, convenient read_csv/read_parquet/read_json table-function helpers, extension and checkpoint helpers, and Quack client/server hooks. The module also provides a PostgreSQL-flavored SQL dialect, introspection of DuckDB metadata, and a deploy/diff workflow that test-deploys and compares schemas to generate safe DDL changes. Tests run against in-memory DuckDB databases so no external credentials are needed, and a handy -du shortcut is provided for easy loading. The recent release makes driver errors throw DBIO::Exception objects for consistent error handling and fixes a DROP INDEX versus DROP TABLE collision during full-schema sync; it requires DBIO >= 0.900001.

DBIO::DB2 is a tiny DBIO subclass that makes it trivial to target IBM DB2 by automatically wiring your schema to the DB2-specific storage driver when you connect. Load it into your DBIO schema or use the provided -db2 shortcut and DBIO will use DBIO::DB2::Storage so your application can take advantage of DB2-aware introspection, DDL generation, schema diffing and deployment without having to name the storage class yourself. It is the right choice if you use DBIO as your ORM and need seamless support for DB2 databases. The recent 0.900001 release fixed a schema-diff edge case that could emit conflicting DROP INDEX and DROP TABLE statements and now suppresses standalone index drops when their table is also being dropped, and the distribution now requires DBD::DB2 and DBIO >= 0.900001.

DBIO::Async provides a shared, loop-agnostic asynchronous layer for DBIO drivers, centralizing the Future and Future::IO requirements and the common async plumbing so that sync-only drivers do not pick up async dependencies. It supplies a DB-agnostic Storage base class (DBIO::Async::Storage) that implements the generic CRUD runner, transaction pinning, pipeline bracketing, sync fallbacks and AccessBroker wiring while expecting each DB-specific driver to subclass it as DBIO::YourDriver::Storage::Async and supply the transport-specific seam hooks such as how to submit a query, collect results and which socket fileno to watch. Asynchronous mode is explicit: connecting with { async => "future_io" } resolves the per-driver adapter by convention and will fail early if a driver has no async adapter, and loading DBIO::Async does not globally enable async for every driver. The watcher seam is event-loop agnostic because Future::IO defaults to IO::Poll and can route to IO::Async, AnyEvent, Mojolicious, UV or Glib when those implementations are installed, so an external event loop is optional. This first release also brings a Pool subclass and a TransactionContext, improves SQL placeholder shaping and connection-ready handling, wraps driver poll file descriptors into stable filehandles to avoid watcher races, and moves the Future deps out of drivers so installing DBIO::Async is the switch that turns async support on.

DBIO::Sybase is a small DBIO schema component that makes using Sybase databases with the DBIO ORM effortless by pinning your schema's storage to DBIO::Sybase::Storage so connections automatically use the right Sybase driver. Load it with the handy shortcut use DBIO 'Schema', -syb and your schema will select a concrete storage subclass at connect time, reblessing into server-specific handlers for Sybase ASE or for Microsoft SQL Server accessed via DBD::Sybase; the storage layer also includes support for FreeTDS connections, LOB handling, bulk insert and other Sybase-specific behaviors. If you manage deployments or schema introspection the distribution also contains native introspection, diff and DDL tools tailored to Sybase. The recent release fixes a bug where MS‑SQL connections were not being reblessed into DBIO::MSSQL::Storage::Sybase and avoids a prior conflict around dynamically composing a FreeTDS trait, so cross‑vendor connections now resolve correctly without forcing a hard dependency.

DBIO::SQLite is the lightweight SQLite driver component for DBIO that makes it easy to use SQLite-backed schemas by automatically configuring DBIO to use SQLite-specific storage and SQL generation. Loading the component (or using the -sqlite shortcut) pins the schema's storage_type to DBIO::SQLite::Storage so your connections, deployments and result classes work with SQLite without extra boilerplate. It is mainly a compatibility shim created when SQLite storage and SQLMaker were split out of the older DBIx::Class distribution, it supports DSN autodetection when present and is suitable for normal development or in-memory testing workflows.

DBIO::PostgreSQL is the PostgreSQL driver component for the DBIO ORM that gives your schema PostgreSQL-native storage, SQL generation, schema introspection, diffing and deploy tooling. Loading the component pins DBIO::PostgreSQL::Storage for connections and provides a -pg shortcut for result classes so you can declare schema-qualified tables, native types like text arrays and UUID defaults, and PostgreSQL-specific indexes, extensions and search_path settings. The distribution includes an introspector to build a live model from pg_catalog, a diff/DDL engine that emits ALTER/CREATE/DROP statements, and a Deploy helper that can test-deploy your desired schema into a temporary namespace and apply upgrades. The recent release adds true non-blocking support with a future_io-based Storage::Async implementation and an opt-in 'ev' async mode, fixes a DROP INDEX versus DROP TABLE CASCADE diff edge case, and adds documentation and a security policy. If you use DBIO with Postgres and need correct Postgres SQL, live introspection or automated schema deployment, this module is likely relevant.

DBIO::MySQL provides the MySQL and MariaDB driver components and schema-management features for the DBIO ORM, letting your schema class automatically use a MySQL-aware storage implementation for native DDL generation, introspection, diffing and deploy operations. It supplies a MySQL-flavored SQL generator, database-aware Result attributes for declaring engine, charset and collate, and tools to compare and apply schema changes against a live server or temporary database, with optional MariaDB-specific subclasses where the behavior differs. If you use DBI with a dbi:mysql or dbi:MariaDB DSN this module hooks into DBIO so you get correct SQL and schema handling without manual storage wiring. The recent 0.900001 update adds non-blocking async storage adapters and an "ev" async mode registration so future_io-style async DB access is supported for both DBD::mysql and DBD::MariaDB, and it fixes several MySQL 8 introspection and schema-diff bugs while adding a security policy and improved test tooling. This module is relevant if you manage schemas or deploy applications that target MySQL or MariaDB from DBIO and want accurate DDL, introspection and optional async database I/O.

DBIO is a modern Perl ORM built on DBI that maps database rows and queries to objects while keeping database-native behavior, offering three ways to declare schema and result classes: a DDL-like Cake DSL, a Candy import sugar, or the classic Vanilla style. It gives you lazy, composable ResultSets that only query when needed, automatic joins from relationship conditions, prefetch for efficient eager loading, multi-column keys, and driver-specific SQL features through native driver distributions like DBIO::PostgreSQL and DBIO::MySQL. You use a Schema connected to a DBI DSN and then call resultset(...)->search, create, update, delete and transaction helpers to work with rows in an expressive, declarative way. DBIO is a clean-namespace fork of DBIx::Class with several architectural changes such as swapping to SQL::Abstract and moving driver logic into native distributions, and the core API is substantial and usable though still pre-1.0 so a few edges are being refined.

Jacode4e::RoundTrip is a Perl module for converting Japanese character encodings with an emphasis on preserving JIS X 0213 characters so they can be round-trip transferred between legacy enterprise and mainframe encodings and modern UTF-8 variants. It exposes a simple API, Jacode4e::RoundTrip::convert, which updates a string in place and returns the character count, and accepts source and target encoding names such as cp932x, cp00930, keis78, keis83, keis90, jef, jipsj, jipse, letsj, utf8, utf8.1 and utf8jp along with options to declare input layout, enable output SI/SO shifting, set DBCS/MBCS space and geta fallback codes, and supply override mappings. The module automatically handles SI/SO kanji shift codes when present and lets you force SBCS/DBCS layout for enterprise encodings that rarely use shift codes. It was designed to help systems exchange and restore JIS X 0213 data by using user defined areas and special encodings like CP932X and UTF-8-SPUA-JP, but for reliable round-trip conversion you must use the same version of the software for both directions and be aware that older releases had some mapping errata that were corrected in later updates. If you need to interoperate with Japanese enterprise character sets while retaining JIS X 0213 fidelity this module is directly relevant and it runs on Perl 5.005_03 and newer.

Dist::Zilla::PluginBundle::DBIO is a ready-made Dist::Zilla bundle for building, testing, and releasing DBIO-related Perl distributions. It composes a set of sensible defaults and plugins so your repo gets git-aware file gathering, metadata from a cpanfile, Pod::Weaver powered documentation tuned for DBIO, extra-test handling that moves integration tests into releases, and an automated coverage test that reads Devel::Cover output and can enforce a coverage threshold. The bundle also generates repository and META links for Codeberg or GitHub, enforces releasing from the main branch, and expects a committed LICENSE file. Special modes support distributions that carry code derived from DBIx::Class by adding the appropriate copyright and attribution and alter some defaults for the DBIO core release workflow. Configurable attributes include heritage mode, the copyright holder string, which skills to ship as runtime shared data, and the required coverage percentage, making this bundle a convenient choice if you maintain a DBIO driver, a heritage driver based on DBIx::Class, or the DBIO core.

App::Test::Generator is a practical toolkit for Perl authors who want to automatically strengthen their test suites by generating black-box fuzz, edge-case, property-based and mutation-aware tests from simple input/output schemas. You write a YAML or Perl schema describing a routine's parameters and expected output and the generator emits Test::Most test harnesses that combine randomized fuzz inputs, deterministic boundary checks, static corpus cases and optional Test::LectroTest properties, with support for semantic generators like email, UUID and timestamps, reproducible seeds and configurable iterations. The distribution also includes mutation testing, LCSAJ path metrics and a web-style test dashboard, a SchemaExtractor that heuristically produces schemas from .pm files, tools to minimize and manage fuzz corpora, a pod-example tester that converts POD examples into round-trip tests, a benchmark generator and helpers to deploy GitHub Actions workflows so this can run in CI. A mutation-guided pipeline can turn surviving mutants into TODO stubs or augmented schemas so tests evolve automatically, making it a good fit for CPAN module maintainers and CI-driven quality workflows. Recent releases added corpus minimization and CI workflow deployment and fixed several edge-case bugs including a 0.43 patch that corrects number/float behavior when min is less than or equal to zero.

App::DesktopWorkspaceUtils is a small CPAN distribution that provides simple command-line utilities for working with DesktopWorkspace files. It installs two programs, list-desktop-workspace-items to show the items declared in a workspace specification and open-desktop-workspace-items to launch those items. Use it when you want to inspect workspace definitions or automate opening the applications and documents they describe. This is the initial 0.001 release.

Mojolicious::Plugin::Fondation::Model::DBIx::Async brings DBIx::Class::Async into Fondation-powered Mojolicious apps so you can use native DBIx::Class ResultSet APIs while database work runs in a background forked worker pool and your event loop stays responsive. It supports multiple named backends and simple model-to-table mapping in configuration, provides controller helpers to access schema and models, and returns Future objects for all async DML operations. The plugin auto-discovers Result and ResultSet classes from other plugins, forks workers lazily on first use, and performs a graceful shutdown on exit so workers are cleaned up. If you already use DBIx::Class this is a drop-in way to make queries nonblocking, just remember to retain Future chains until completion. The recent 0.03 release added Fondation setup integration, reorganized the ResultSet code and introduced a fluent ResultSet->with() helper for many-to-many prefetching along with assorted bug fixes and improved source registration.

Language::Prolog::Sugar is a small Perl helper that exports constructor subroutines so you can build Prolog terms in Perl with a Prolog-like appearance. You declare which atoms, functors, variables or chain operators you want and the module installs subs that produce Language::Prolog::Types term objects, with functor arity inferred from the number of arguments and chains making nested comma or semicolon structures easy to construct. There is also an auto_term option that AUTOLOADs undefined names as terms for rapid prototyping. It is useful when you need to generate Prolog terms to drive a Prolog engine or to create a Prolog-like DSL in Perl. The author notes it cannot reproduce Prolog operator syntax, so you still invoke constructors as functions rather than using real operator forms.

Slug is a small, fast XS-based Perl module that converts arbitrary UTF-8 text into URL-safe, SEO-friendly slugs for web apps, filenames and permalinks. It transliterates Unicode to ASCII, lowercases and replaces non-alphanumeric characters with a configurable separator and offers a simple slug() call, slug_ascii() for transliteration-only output, and slug_custom() to control separator, max length, case, transliteration and trimming. The implementation uses custom ops on Perl 5.14 and newer for minimal overhead and also exposes its C headers so the core can be reused in other projects. The initial 0.01 release includes broad Unicode transliteration coverage for Latin, Greek, Cyrillic, Vietnamese, symbols, ligatures and fullwidth characters along with custom separator support, so if you need a quick, configurable and high-performance slug generator in Perl this module is a good fit.

OpenAPI::Modern is a Perl toolkit for checking that HTTP requests and responses conform to an OpenAPI v3.0, v3.1 or v3.2 specification, returning a structured JSON::Schema::Modern::Result that shows whether a message is valid, lists detailed schema errors, and carries the deserialized parameter and body data for further processing. You build it from your OpenAPI document or schema and then call validate_request or validate_response to match incoming Mojolicious (or best-effort converted) request and response objects to the right path and operation in the spec, with support for JSON Schema dialects, format validations, default population, and bundled metaschema documents to simplify schema resolution. The module is tuned for server use where you may preload and cache parsed documents to avoid startup cost and it can handle content-encoding and media-type based parameter bodies, including examples for carrying structured data in cookies. Do note that parsing is based on Mojolicious message objects so other frameworks are converted best-effort, multipart support and some path-item $ref patterns are not implemented yet, and the module does not itself enforce Authorization schemes. If you need rigorous, spec-aware request and response validation against modern OpenAPI schemas, OpenAPI::Modern provides a comprehensive and extensible solution.

CGI::Lingua is a Perl helper for making CGI web sites multilingual by negotiating the visitor's preferred language and region against a list of languages your site supports. You construct it with the languages you provide and it exposes simple methods to get a human readable language name, the two letter language or region codes, the requested sublanguage, and a best-match translation file in a directory. It can also infer the visitor country from the client IP using common Geo modules or a Whois fallback, provide a locale object and a time zone, and tell you whether the chosen language is right-to-left so you can set HTML direction. Additional features include CLDR-like plural category selection for integers across many languages and optional CHI caching and logging integration. Note the module uses embedded plural rules rather than full Locale::CLDR, RTL detection covers primary-script RTL languages only, Whois fallbacks are slow so installing a local geo module and enabling cache is recommended, and a provided logger must be a blessed object; these are known limitations documented by the author.

Apophis is a lightweight XS Perl library that provides filesystem-backed content-addressable storage using deterministic UUID v5 identifiers derived from SHA-1. It produces the same UUID for identical content and allows different namespaces so the same bytes can map to different ID spaces, which makes it handy for deduplication, immutable artifact storage, or reproducible file identifiers. Objects are sharded into a two-level hex directory tree for scalable on-disk layout, writes are atomic, and duplicate content is naturally deduplicated so no locking is required. The API supports streaming identification of large files with constant memory, atomic store and fetch operations, existence checks, integrity verification, bulk store/find operations, and optional metadata sidecars. Apophis depends on the Horus UUID library and is a good fit when you want a simple, local CAS with deterministic IDs rather than a networked storage system.

PDF::Make is a comprehensive Perl toolkit for creating, reading, and editing PDF files. It offers a recommended high-level, chainable Builder API that handles layout, word wrap, fonts and page management for common document tasks and a low-level XS API when you need direct control of PDF objects and content streams. The distribution covers document creation, parsing and text extraction, images and TrueType fonts, annotations, interactive forms, layers and attachments, redaction and watermarks, encryption and digital signatures, and can produce linearized PDFs for fast web viewing. Runtime dependencies are minimal and the Builder API makes everyday tasks simple while the XS layer lets you implement advanced, specification-level behaviors. The recent 0.07 release fixes a Windows memory-management bug that could cause crashes on Strawberry Perl by correcting how native buffers are freed.

App::bcrypt is the packaging around a small command line utility for creating and verifying bcrypt password hashes; the Perl module distribution mainly exists to reserve the namespace and to install the utility's prerequisites rather than to provide a feature-rich library API. The tool uses Crypt::Bcrypt and is related to a couple of Mojolicious bcrypt integrations, so grab this distribution when you want a straightforward Perl-based bcrypt CLI or need to bring bcrypt support into a Perl project. The distribution is maintained on GitHub and has seen light maintenance since its 2023 initial release, including packaging and test fixes through 2026.