CPANscan

Net::CIDR::Set is a Perl module for representing and manipulating collections of IP addresses and ranges. It accepts CIDR blocks, explicit start-end ranges or single addresses and supports standard set operations such as union, intersection, complement, difference and exclusive-or, plus membership tests and subset/superset checks. The module works with both IPv4 and IPv6 but you cannot mix them in the same set and it will automatically coalesce overlapping ranges into the most compact representation. It provides iterators and convenience methods to enumerate addresses, CIDR blocks or ranges and to produce compact string output with several formatting options, though expanding a set into every individual address can use very large amounts of memory for big ranges or IPv6. You can create, copy, invert and merge sets programmatically, and the module requires Perl 5.14 or later with its source maintained on GitHub.

Device::Chip is a framework for building and using Perl drivers that talk to real hardware chips and modules, providing a consistent, high-level interface so drivers can focus on device behavior while delegating port access to an adapter. A driver instance is "mounted" to an adapter that implements the Device::Chip::Adapter interface, enabling communications over common protocols such as I2C, SPI, UART and GPIO, and the API supports both asynchronous operation via Future objects and simple synchronous use via Future->get. The module supplies conveniences for script-style option parsing with mount_from_paramstr, a base for registered I2C devices and a sensor abstraction used by many subclasses, and it includes test helpers to simplify unit testing of chip drivers. The distribution is actively developed and documented for driver users and authors, and the latest notable change merges sensor declarations from superclasses to make sensor definitions more composable.

ClickHouse::Encoder provides a fast XS-backed toolkit for producing and consuming ClickHouse Native and RowBinary payloads from Perl. It turns Perl rows or column arrays into ClickHouse-native columnar blocks that you can POST over HTTP, pipe into clickhouse-client, or send over the native protocol, and it can also decode query responses block by block or stream them with bounded memory. The module includes high-level features for schema discovery and diffs, create table rendering and parsing, bulk inserters with auto-flush and retries, streaming writers and compressors, helpers for decimals and WKT geometries, and good support for ClickHouse types including Arrays, Tuples, LowCardinality, Variant, JSON typed paths, DateTime variants, and high precision Decimals. It is optimized for throughput by doing type parsing up front and heavy work in XS so you can reuse one encoder per schema, and it fails loudly on malformed inputs to surface data issues early. Note the practical caveats that a 64 bit Perl is required and encode builds a whole Native block in memory, and that JSON array edge cases are an interoperability limitation.

This module is only a tiny placeholder used to ensure the distribution is indexed by CPAN and carries no runtime functionality; it exists for package authors rather than for end users and is not normally installed on a user system, so ordinary users can safely ignore it while authors include it to satisfy CPAN indexing requirements.

JSON::YY is a high-performance Perl JSON module built on the yyjson C library that gives you three ways to work with JSON: a lightweight functional/keyword API for the fastest encode and decode calls, an object-oriented API compatible with JSON::XS for configurable encoding and decoding, and a Doc API that exposes yyjson's mutable document tree so you can read or surgically edit JSON using JSON Pointer paths without fully materializing the data as Perl structures. It supports a zero-copy read-only decode mode for large inputs, compiles common operations to custom ops for speed, and shines on large payloads and targeted modifications where the Doc API can be several times faster than decode-modify-encode. Be aware that canonical key ordering is not implemented, JSON booleans decode to Perl 1 and 0 rather than overloaded boolean objects, NaN and Infinity cannot be encoded, and nesting depth is bounded by max_depth to avoid stack exhaustion. The release series has continued stability and safety improvements with the recent 0.07 update addressing an encoder heap overflow, crash and double-free fixes, and various correctness fixes including Latin-1 handling and better scalar/Doc behavior.

StreamFinder is a Perl library that extracts actual raw streamable URLs and metadata from radio station, podcast and video pages so you can play them in your own media player instead of a browser. You give it a page URL and it selects a site-specific handler to return one or more playable stream URLs along with title, description, artist/channel, cover art or banner images, duration and other fields where available, and it can fetch image data for local use. It is designed to be embedded in other Perl programs rather than used as a standalone app and is already used by the Fauxdacious media player to avoid browser JavaScript, ads and trackers. Many video handlers use yt-dlp or similar tools and there are configuration files and options to control behavior such as forcing HTTPS-only streams, limiting HLS bandwidth, omitting handlers, and logging. Supported sites cover YouTube, Vimeo, Apple Podcasts, TuneIn, Rumble, Bitchute and many podcast and radio sources plus a generic Anystream fallback, with some modules marked deprecated or removed when sites became heavily JavaScripted or cookie-locked. A recent notable improvement adds DASH support in the YouTube handler so the module can return paired audio and video URLs for higher-quality playback by players that can consume both streams simultaneously.

Math::NLopt is a Perl binding to the NLopt nonlinear optimization library that lets Perl programs run a wide range of local and global optimizers for functions with or without gradient information. It provides a Perlish, object-oriented API using native Perl arrays and relies on Alien::NLopt to locate or install the underlying C library. You create an optimizer by choosing an NLopt algorithm and the number of parameters, supply objective functions and optional constraints or preconditioners, set bounds, tolerances and other options, and call optimize to obtain the best parameter vector and objective value. The module exposes the NLopt algorithms and result codes as importable constants, returns results directly from methods, and by default throws exceptions on errors while offering an option to disable exceptions for optimize so you can inspect the last recorded parameters. Use Math::NLopt when you need proven, flexible nonlinear optimization from Perl with support for constrained problems and both gradient and derivative-free methods.

Compression::Util is a function-based Perl library that collects a broad set of compression primitives and ready-made compressors so you can build, experiment with or use common formats entirely in Perl. It includes high-level compressors and decompressors for bzip2, gzip, zlib, LZ4, LZ77/LZSS and LZW and supplies the building blocks behind them such as Burrows-Wheeler, move-to-front, Huffman and arithmetic coding, run-length and Elias/Fibonacci coders, DEFLATE helpers, CRC/Adler checksums and bit and byte I O utilities. The API is modular and designed to be combined into pipelines or used piecewise, with tunable package variables for LZ parsing like LZ_MIN_LEN, LZ_MAX_LEN and LZ_MAX_CHAIN_LEN and optional exports so you only pull in what you need. Recent changes add a fast LZSS hash routine for LZ4-style parsing and a new LZ chain width parameter, improve match selection for some inputs and fix a hang in the symbolic BWT sorter, making the module faster and more robust. This module is a good fit for developers building custom compressors, researchers or students studying compression algorithms, and anyone who needs pure‑Perl implementations and flexible components without external dependencies.

Astro::SpaceTrack is a Perl module and command-line shell for retrieving satellite orbital elements and related catalogs from Space-Track.org and several public providers such as CelesTrak and selected third-party mirrors. It provides high-level methods to search by name, date, launch ID or NORAD catalog number, to retrieve batches of TLEs in multiple formats (including JSON), and to call CelesTrak supplemental catalogs, with most retrievals returning an HTTP::Response object annotated with pragmas that indicate data type and source. Some functions require a registered Space Track username and password and the module can optionally read credentials from a Config::Identity file for unattended use, while other sources (CelesTrak, some mccants endpoints) do not need an account. The distribution includes a SpaceTrack wrapper script and an interactive shell for ad hoc queries and file updates, plus an update() helper to refresh JSON TLE files locally. Be aware that parts of the code are a web-scraper and depend on the stability of upstream web pages, and several legacy features have been deprecated or removed over recent releases so some historical Iridium and favorites functionality is no longer available; recent updates also added the CelesTrak SAR catalog and now throw an exception if you attempt to fetch the removed “canned favorites.”

DB::Handy is a self-contained, pure-Perl relational database engine that stores tables as fixed-length binary files and gives you a familiar DBI-like API — connect, prepare, execute, fetchrow_hashref, selectall_arrayref and friends — without any external server or non-core modules. It implements a surprisingly large slice of SQL‑92, including SELECT with JOINs and subqueries, aggregates, set operations, ORDER BY, LIMIT/OFFSET and single-column indexes to speed equality and range lookups, and it also exposes a lower-level engine API for direct file and schema operations. It is designed for portability and simplicity rather than full RDBMS fidelity, so it is not a DBI driver, it always runs in AutoCommit mode with no transaction support, it has no BLOB/CLOB or multi-column indexes, VARCHAR fields always occupy 255 bytes on disk and FLOAT values in .dat files are machine-native and therefore not portable across different architectures. The 1.10 release adds an important portability and integrity fix on Windows by rejecting reserved device names like con, prn and nul so tables and indexes cannot be accidentally written to the bit bucket, along with a raft of hardening and test-suite fixes. Use DB::Handy when you want an easy, dependency-free embedded SQL engine for modest datasets and simple queries and you can live with the documented limitations.

Dancer::Plugin::Auth::Google makes it easy to add Google OAuth2 sign‑in to a Dancer web app. It provides an initialization helper and a function that builds the Google authorization URL, automatically creates the /auth/google/callback route, and saves the authenticated user profile and tokens into the session so your app can check session('google_user') to know who is logged in. You must supply a session backend and register a Google application to get a client id and secret, then put those and a callback URL into your Dancer config. The default scope is profile but you can request additional scopes such as email or Drive. The saved session includes access and refresh tokens so you can call other Google APIs on behalf of the user. The module verifies TLS certificates by default to prevent MitM attacks and offers an insecure option for legacy behavior, and it also provides a legacy_gplus flag to reproduce the old Google Plus profile format if needed.

Dist::Zilla::PluginBundle::Author::ETHER is an opinionated, ready-made collection of Dist::Zilla plugins that encodes Karen Etheridge's preferred workflow for building, testing, and releasing Perl distributions. By adding [@Author::ETHER] to your dist.ini you get a preconfigured pipeline that handles file gathering, metadata and license management, pod weaving, a broad suite of quality and portability tests, Git and GitHub integration, and automated versioning and release steps. The bundle is configurable so you can pick installer backends, choose repository servers, enable an offline "airplane" mode, produce a cpanfile, perform fake releases for testing, and more while still benefiting from sensible defaults. It is ideal for Perl authors who already use Dist::Zilla and want a mature, flexible, maintained release setup without handcrafting every plugin.

Crypt::DES is a straightforward Perl wrapper that provides the classic DES block cipher with a Crypt::CBC-compatible interface, offering methods like new(key), encrypt, decrypt, blocksize and keysize. It operates on 8-byte blocks and uses 8-byte keys, so it is best used as a building block inside higher-level modes such as Crypt::CBC when you need to handle larger or streaming data. The module is maintained and portable across platforms, but the authors explicitly warn that DES is cryptographically weak and can be brute-forced on modern hardware, so you should not rely on it for real security. Recent updates added an explicit Security Considerations section and clarified replacement recommendations, pointing users toward modern alternatives such as Crypt::Cipher::AES (CryptX) or authenticated modes like Crypt::AuthEnc::GCM. If you need legacy DES compatibility or for testing and learning purposes this module is convenient, otherwise choose a contemporary cipher for any security-sensitive work.

Module::Metadata inspects Perl module files and extracts useful metadata such as package names, $VERSION values, and POD text without having to fully load the module into your program. It offers constructors to read from a filename, an open handle, or by finding a module on @INC, and can optionally collect and decode POD sections. The module evaluates version assignments in a controlled environment so it can return accurate version objects and it can generate CPAN META "provides" structures for a directory or a list of files, find module paths, and test whether packages are indexable by PAUSE. This is handy for CPAN authors, build tools, packaging scripts, and anyone who needs reliable module metadata for testing, packaging, or automation. Recent releases improve parsing for modern Perl "class" declarations and attribute syntax and include small test updates to handle upcoming Perl taint behavior changes.

PlackX::Framework is a lightweight micro‑framework built on Plack for creating PSGI web applications. It wires together a handler, request and response objects, and a small routing DSL so you can define routes and filters with minimal ceremony and call MyApp->app to get a PSGI app. Request and response objects extend Plack::Request and Plack::Response and provide a per-request stash and a flash cookie helper. The framework will auto‑create or load MyApp::Handler, ::Request, ::Response, ::Router and other pieces in your application namespace to keep setup simple. Template Toolkit support, URI helpers and a simple config layer are optional and pluggable so you can add them only when needed. The project favors low memory use and fast startup compared with larger frameworks and keeps dependencies small. It is still marked experimental and recent releases have focused on documentation and test fixes with the distribution published to CPAN in 2026.

Attribute::Handlers::Clean is a lightweight drop-in for defining Perl attribute handlers without polluting the UNIVERSAL namespace, so you can attach custom behavior to variables and subroutines declared in your module or its callers and subclasses while avoiding global side effects. You declare handlers as normal subs with the :ATTR annotation and they will be invoked during compilation or runtime phases with information about the package, symbol, referent and any attribute data, and the module supports type-specific handlers for scalars, arrays, hashes and code, raw-data mode to skip attribute parsing, and phase control such as BEGIN, CHECK, INIT and END. It also automates a common pattern for tying variables via autotie and autotieref, and provides a findsym utility to locate and memoize typeglobs for referents. The code is largely adapted from Damian Conway's Attribute::Handlers but scoped to the calling packages to avoid UNIVERSAL pollution, and note that as of version 1.06 the module requires Perl 5.010 or newer and the author acknowledges there may still be bugs.

Google::Auth is a lightweight Perl library that implements Google Application Default Credentials and automatic project ID detection so your Perl programs can obtain and refresh Google Cloud access tokens without wiring up OAuth flows yourself. It provides a simple default($scopes, $options) entry point that returns the best credentials for the current environment, whether that is a service account key, Compute Engine metadata, or external/federated account configurations, and exposes environment switches to control pluggable credential behavior. Recent releases added full OAuth2 browser flows with UserAuthorizer, WebUserAuthorizer, and a FileTokenStore, a gcloud-auth CLI dispatcher, and substantial security and compatibility hardening including safer external credential execution, stricter URL and proxy handling, and improved OpenSSL support. Use Google::Auth when you need standard, supported Google Cloud authentication in Perl with token management handled for you.

Workflow is a mature, standalone Perl workflow engine that models business processes as named states and actions that move an item between those states while consulting pluggable conditions and validators. You feed the system simple configuration files and use Workflow::Factory to create or fetch Workflow objects, then interrogate a workflow for available actions, required input fields, and a Workflow::Context that acts as a blackboard for your application data. The design is modular so you can supply custom action, condition, validator, observer and persister classes to store workflows in a database, the filesystem or other storage backends. Observers let other parts of your system react to events such as state changes and completed actions. Configuration now favors YAML over the older XML reader which the project plans to remove in a future major release. The distribution is actively maintained on GitHub and the latest 2.11 release fixes a packaging bug in the release tarball, so updating is recommended.

CryptX is a comprehensive Perl cryptography toolkit that bundles the LibTomCrypt and LibTomMath engines and exposes a large family of focused modules for hashing, authenticated encryption, block and stream ciphers, MACs, public‑key operations, secure randomness, key derivation, ASN.1 parsing, and a Math::BigInt backend. It is the distribution entry point rather than a single API, so you pick the concrete modules you need such as Crypt::AuthEnc for AEAD, Crypt::Digest for hashes, Crypt::PRNG for secure random bytes and tokens, Crypt::Mac for message authentication, and Crypt::PK for public‑key tasks. The docs give practical guidance and sensible defaults, recommending modern AEADs like ChaCha20‑Poly1305 or XChaCha20‑Poly1305 as first choices, AES‑GCM when hardware acceleration is available, Ed25519/X25519 for signatures and key agreement, and Argon2 for password hashing. Most modules croak on bad parameters while authenticated decrypt helpers return undef on verification failure so tampering can be detected. The project is actively maintained and recent changes added AES‑XTS mode and BLAKE3 digest support among other fixes and bundled library updates, making CryptX a solid choice when you need a broad, interoperable cryptography toolbox in Perl.

Stats::LikeR is a high-performance Perl toolkit that brings many of R's convenient statistical routines and data-frame style helpers into Perl, implemented mostly in XS so common operations run fast. It covers tidy-data reshaping and querying (agg, group_by, melt, pivot_table, concat/rbind, merge, join, select/drop columns, assign, filter), numeric summaries and transforms (mean, median, quantile, rank, scale, interpolate, fillna/ffill/bfill), a wide suite of statistical tests and estimators (t test, wilcoxon, chi-square, fisher, anova/aov, oneway_test, kruskal/dunn, binomial tests, correlations, ROC/AUC/DeLong, BEDROC), regression and modeling (lm, glm with Poisson and negative binomial, coxph, survfit, logrank), and convenient table I/O (read_table, write_table) while accepting multiple common frame shapes (array-of-arrays, array-of-hashes, hash-of-arrays, hash-of-hashes). The API is aimed at people who like R idioms but need to stay in Perl, and many routines are numerically validated against R and SciPy so you get both familiar behavior and careful tail/precision handling. Recent maintenance releases focused on correctness and robustness, with fixes that bring chisq_test into bit-for-bit agreement with R 4.6.1 and further bug fixes and XS improvements in versions 0.296 and 0.297, so the module is a good choice if you need fast, R-like statistics inside Perl.

App::Test::Generator is a toolkit that helps you automatically create rigorous tests for Perl code by turning formal input/output schemas or heuristically extracted signatures into runnable fuzzing, property-based and corpus tests. It generates Test::Most harnesses from YAML or extracted schemas, produces deterministic edge-case checks alongside randomized fuzzing, supports semantic generators for realistic data and Test::LectroTest properties, and can validate outputs with Return::Set and Params::Validate::Strict. The distribution also bundles command line tools to extract schemas from .pm files, generate benchmarks, test POD examples, run mutation testing and LCSAJ path analysis, deploy ready-made GitHub Actions workflows, and build a combined coverage and mutation dashboard that helps reproduce and triage CPAN Testers failures. A mutation-guided pipeline can turn surviving mutants into TODO stubs or augmented schemas so CI progressively closes testing gaps. Recent releases added corpus minimization to keep fuzz corpora small and fixed several robustness issues including cleaning up stray files created during test runs and improving schema extraction.

Developer::Dashboard is a local developer "home" that gathers your bookmarks, notes, helpers, health checks, file and path shortcuts, Docker Compose workflows, and small automation tasks behind one consistent entry point: a browser UI, prompt status layer, and a single CLI that all share the same runtime. It stores saved pages and executable bookmark blocks with Template Toolkit rendering, runs background collectors to prepare cached state for fast prompt and web indicators, and exposes handy CLI tools for opening files, resolving Perl and Java names, and querying JSON, YAML, TOML, properties, CSV and XML. The runtime is layered so a project-local ./.developer-dashboard can override your home settings while still falling back to ~/.developer-dashboard, helpers are staged privately to avoid polluting PATH, and a simple skills system lets you extend the dashboard with isolated plugins. The packaged web server runs on port 7890 with optional HTTPS and a deliberate loopback-based access model, runtime files are hardened by default, and cross-platform installers and commands are provided for Unix and Windows. If you want a single, configurable place to collect per-project shortcuts, repeatable health checks, status indicators, and lightweight automation that works across language stacks, this module is directly relevant; it is implemented in Perl but is designed to help mixed-language teams as well.

App::Netdisco is an open source, web‑based network management application that discovers devices via SNMP and stores collected data in PostgreSQL so you can locate machines by MAC or IP, see the switch port they use, manage ports (shutdown, VLAN, PoE), inventory hardware, and generate network diagrams. It bundles a web frontend with a built‑in server and a backend daemon for polling and performing actions, and it supports plugins, a DBIx::Class database API, Docker images for easy deployment, and an online demo to try before installing. The project targets administrators of real networks, documents installation and upgrade steps, and requires Perl 5.10+ and PostgreSQL 9.6+ with additional system packages for full functionality.

Lingua::Word::Parser is a Perl module that breaks a word into known and unknown parts by matching a regex-driven lexicon of affixes loaded from a file or a database. You create an instance with the target word and a lexicon source and then use methods like knowns to list matched fragments, power to enumerate non-overlapping partitions, and score or score_parts to rank candidate partitions by character coverage, chunk counts and a simple familiarity metric while returning human-readable definitions for matched parts. Lexicon entries are regular-expression patterns mapped to short definitions so you can capture prefixes, suffixes and combining forms. The module is handy for lightweight morphological analysis, tokenization helpers, spelling or learning tools, and small NLP pipelines where you want readable partitions and scores rather than deep linguistic modeling.

BATsh is a pure-Perl, cross-platform bilingual shell that lets you write and run scripts combining Windows cmd.exe batch syntax and Unix bash/sh syntax in the same file, switching mode automatically on a line-by-line basis while sharing variables through a common BATsh::Env. It implements a large subset of both worlds including pipelines, I/O redirection, functions, positional parameters, arrays, brace and tilde expansion, command and arithmetic substitution, traps, getopts, and CP932 (Shift_JIS) script support, so you can run mixed CMD/SH examples without needing an external cmd.exe or /bin/sh. Non-built-in utilities are invoked as external programs and therefore require the corresponding executable on the host OS, and a few words like the reserved "time" are intentionally not implemented. The 0.11 release fixes several practical interpreter issues: one-line control structures now allow trailing commands and redirections as bash does, the REPL startup bug was repaired, backgrounded builtins no longer escape to an external shell, and documentation was unified, making the module more robust for interactive use and mixed-mode scripts. If you need to run or teach mixed Windows and Unix shell code, or want a single interpreter to experiment with both syntaxes from Perl, BATsh is likely relevant.

Music::ModalFunction is a Perl utility for querying a Prolog-based music theory database to discover relationships between notes, chords, modes or scales, keys and their diatonic functions. You construct an object binding any combination of chord, chord root, mode or key and their functional or Roman-numeral labels, and unbound arguments return all matching possibilities so you can ask things like which chords two keys share, in which modes a given chord can function, or how Roman numeral functions map between scales. Results can be returned as simple lists or as named hash references and you can switch between modal and non-modal scales such as harmonic minor or diminished when needed. Note names use flats only rather than sharps and the module author warns that the choice of the names "mode" and "key" in the API can be confusing, but otherwise the module is a practical tool for composers, arrangers, educators or software that needs to reason about common chords, pivot chords and functional harmony.

WebDyne is the core runtime for the WebDyne framework that renders ".psp" pages to HTML either as the main request handler under servers like Apache/mod_perl, PSGI, or PAGI or as a standalone renderer callable from scripts. It exposes simple functions such as html and html_sr to convert templates that embed Perl into HTML, supports passing parameters, template parsing and caching, chained handlers, filters, CGI-style parameter access, and integration with other WebDyne modules. In standalone mode it will create a fake request object if needed, can write output directly to a filehandle or return the rendered HTML, and a small command line renderer is included for quick generation and diagnostics. Full usage examples and documentation live in the module source and on the project GitHub, making WebDyne a practical choice when you want a Perl-centered templating and request-handling system for web apps or offline page generation.

Class::Simple::Readonly::Cached is a tiny decorator that wraps a Perl object and transparently caches method results so repeated calls with the same method name and arguments are served from cache instead of re-invoking the inner object. It supports a simple in-process hashref for fast ephemeral caching or any CHI-compatible backend for shared or persistent caches, and it records hit/miss statistics and exposes the wrapped object when you need to bypass the cache. This module is best for read-only or effectively immutable objects because the cache is never invalidated automatically, and callers should be aware of limitations in its naive key serialization such as collapsing undef arguments, possible collisions when arguments contain the string "::", and a scalar-vs-list context mismatch that can cause extra invocations. The recent 0.13 release fixes several important bugs including an @ISA-related AUTOLOAD bypass that could silently skip caching, closes a DESTROY-related reference leak, hardens can()/isa() during global destruction, and adds many tests and performance improvements so caching is now more reliable and efficient.

Mojolicious is a modern, full‑featured real‑time web framework for Perl that bundles routing, a plugin system, a powerful templating engine, content negotiation, session and cookie management, form validation, testing tools, a static file server and a built‑in HTTP client so you can build APIs, web apps and WebSocket or event‑driven services without lots of plumbing. It exposes hooks and helpers for application‑wide behavior, supports embedded and command‑line apps and emphasizes sensible defaults and developer ergonomics. The project is actively maintained and recent releases improved security by masking CSRF tokens per request to mitigate BREACH attacks and added experimental support for partitioned cookies and related session attributes, so it is a good choice if you want a polished, batteries‑included Perl web framework with ongoing security and feature work.

Git::Native is a lightweight Moo-based Perl interface to libgit2 that lets you work with Git repositories natively from Perl without spawning the git executable, making it a good choice when you need many or frequent Git operations or want lower overhead than shelling out. It wraps libgit2 via FFI::Platypus through Git::Libgit2 and provides repository operations such as open, open_ext (searching up from a path), init (including bare repos), validation of reference names, and higher-level actions like creating blobs, building trees, and creating commits or updating refs. Use Git::Native when you want native libgit2 behavior from Perl; it contrasts with Git::Wrapper and Git::Repository, which fork the git binary, with Git::Raw, which is an XS binding that has maintenance and stability issues, and with Git::PurePerl, which is read-only. It requires libgit2 to be available and is maintained on CPAN with a GitHub issue tracker for bugs and contributions.