CPANscan

PAGI::Server is a reference Perl HTTP server that implements the PAGI application protocol and provides HTTP/1.1, WebSocket, and Server-Sent Events with experimental HTTP/2 support, making it a good choice when you need a canonical, spec-compliant server for development, testing, or as a backend behind a reverse proxy. It focuses on clarity and correctness rather than microbenchmarks and includes production-oriented features such as optional TLS, Unix domain socket support, multi-listener and systemd socket activation, a prefork worker model with hot restart, per-connection limits and timeouts, streaming file responses, and IO::Async integration for embedding in an event loop. Experimental features and tunables are well documented and most work out of the box, but HTTP/2, Unix socket and multi-listener modes are still labeled experimental and Windows is not supported. The recent 0.002007 release tightens PAGI conformance by advertising PAGI 0.4, makes outbound event validation and strict send sequencing mandatory, and delivers a number of important HTTP/2 fixes and improvements including trailers support, safer per-stream backpressure and more reliable WebSocket-over-HTTP/2 framing, plus a raised nghttp2 dependency floor and the removal of the deprecated lifespan_mode 'off', so be sure to read the notes before enabling experimental features.

Markdown::Perl is a pure-Perl Markdown-to-HTML converter that aims to be flexible and configurable while following the CommonMark spec and many popular extensions. You can use it as an object or as simple functional calls, set named modes to mimic other processors, and tweak many options to control syntax and output. The module exposes hooks so you can resolve unresolved link references or receive parsed YAML front matter, and recent releases added support for directive container blocks and improved YAML parsing options. It is the engine behind the pmarkdown tool, so if you want a portable, Perl-native renderer with extension points for custom link or metadata handling, this module is a strong choice.

Database::Abstraction is a read-only ORM for Perl that presents a uniform, SQL-free interface to many backends such as CSV and PSV files, XML, SQLite, DBM::Deep, BerkeleyDB, remote HTML tables, or any DBI database via a DSN. You use plain Perl method calls or a chained query builder to do lookups, filtered scans, counts and joins, and you can pass rich criteria including comparison, pattern and set operators as well as logical groupings, with convenient AUTOLOAD column shortcuts for quick access. Small files can be slurped into memory for very fast lookups and there is optional CHI-compatible caching to speed repeated queries while schema introspection helps you inspect columns and types. It is ideal when you want to swap storage formats or avoid writing SQL, but note it is read only, the default CSV separator is nonstandard so set sep_char for RFC CSVs, slurp mode assumes a unique key and XML slurp is limited, and BerkeleyDB lacks joins and the chained query features.

PAGI is a modern specification for writing asynchronous web applications in Perl that extends the familiar PSGI idea to support long‑lived connections like WebSocket and Server‑Sent Events, making it a better fit for real time and streaming use cases. Instead of a single synchronous request/response function, a PAGI app is an async coderef that receives a scope describing the connection and two async callbacks, receive and send, that exchange messages via Futures so you can handle many incoming and outgoing events per connection. The PAGI distribution provides the stable specification and documentation, while a reference server and an application toolkit live in separate distributions, PAGI::Server and PAGI::Tools, which are currently beta, and there are migration guides and examples to help you bring existing PSGI code to PAGI. If you need to build or run async Perl web services, PAGI gives you a simple, standardized interface and an evolving ecosystem of frameworks and helpers to get started.

Map::Tube::Plugin::Graph is a Moo role that plugs into Map::Tube to turn a subway network into a proper graph object and into ready-made images for visualization or embedding. It can produce a multiedged, directed Graph you can analyze or hand to GraphViz2 for layout and export, and it can render whole maps or individual line maps to PNG, SVG, PDF, DOT and other formats with options for layout driver, overlap handling, file output or base64 encoding for web use. The API is simple: as_graph gives you the Graph for programmatic work, render lets you control format, driver and output, and convenience methods as_png and as_image return PNG bytes or a base64 string. You will need the GraphViz2 Perl interface and the GraphViz binary installed and GraphViz2 requires Perl 5.8.8 or newer. This module is useful when you want attractive, configurable tube-network diagrams or to combine network analysis with polished visual output.

Physics::CPD is a lightweight, pure-Perl toolkit for computing the standard parameters of a quasineutral, magnetised plasma from a small set of state variables such as density, electron and ion temperatures, magnetic field and ion species. Temperatures are provided in electron‑volts and other units are SI, and the module exposes simple read/write attributes plus methods that return commonly used diagnostics like Debye length, plasma and cyclotron frequencies, gyroradii, thermal and Alfven speeds, plasma beta, collision frequencies, Coulomb logarithm, mean free path and Spitzer resistivity. It is written with Moo so derived quantities are available as ordinary methods and convenience helpers like as_hash and report make it easy to inspect or print a plasma state. If you work on magnetic confinement fusion or space plasma problems the package gives quick, reliable estimates of the characteristic scales you need. The distribution also includes Physics::CPD::Stellarator, a submodule that adds stellarator geometry, Wendelstein 7‑X defaults, confinement scalings and theoretical D‑T fusion power estimates. The recent release renamed the CPAN distribution to Physics-CPD to align the upload identity with the primary module and clarified the Stellarator component as a modelling submodule.

AmberDB is a compact, high-performance flat-file database engine for Perl that uses DB_File to provide structured record storage, automatic primary keys, on-disk indexes and an ACID-like undo-journal transaction system. It exposes a simple CRUD API plus list, field, filtered and full-text search operations with packed 8-byte binary indexing for very fast ID handling, multi-dimensional facet indexing, tiered Active/Archived query modes, and record- or table-level locking for concurrent access. The module includes language-aware normalization for search (including Turkish-specific rules), runtime schema attribute overrides, and low-level table access for bulk read/write cases, but note that bulk batch operations bypass the transaction journal so single-record methods must be used when rollback safety is required. The recent 5.02 release is the initial public CPAN/GitHub release and highlights include the packed binary indexing pipeline, index-assisted full-text search with phonetic and locale normalization, facet bitset indexing, and a multi-granularity concurrency and transaction engine, making AmberDB a good fit when you want a fast, file-backed store without running a full RDBMS.

Music::CreatingRhythms implements the combinatorial algorithms from Hollos's book "Creating Rhythms" and provides a toolbox for generating and transforming rhythmic sequences. It can produce Euclidean rhythms that distribute onsets across beats, de Bruijn sequences, Christoffel words, paper-folding crease sequences, and common combinatorial families such as compositions, partitions, necklaces and permutations, plus helpers to convert between interval lists and binary on/off sequences. Many routines are direct, efficient ports of the original C implementations and the module also includes small utilities for counting, rotating, reversing and inverting sequence fragments. There are continued fraction utilities including a convergent calculator and an optional sqrt continued fraction routine that uses Math::NumSeq::SqrtContinued when available. Arguments sometimes differ from the book and the most recent release added an edge-case pfold test and documentation fixes. The module is lightweight, practical for algorithmic rhythm generation and is distributed under the Artistic License 2.0.

App::File::Grepper is a small Perl utility for recursively searching files in one or more directories for a text string or regular expression and optionally opening matching files in an editor or pager. You give it a pattern and it will treat leading slashes as Perl regexes while otherwise treating the input as literal text, apply case insensitivity by default when there are no uppercase letters or according to an ignorecase option, and let you further restrict which files are inspected with filter and exclude patterns that match basenames. It can automatically pass matching files to Emacs, vi or less, and it always skips common version control directories and editor backup files. This module is useful when you want a quick, scriptable search across a tree that can jump straight to matches in your editor, and you invoke it by calling App::File::Grepper->main with an options hash and a list of directories.

MCP::Server::KnowledgeStore::Tools::Agent is a small plugin that adds basic agent management commands to an MCP server backed by a KnowledgeStore. It exposes list_agents, get_agent, save_agent, tag_agent and untag_agent so you can store and retrieve agent definitions centrally, with the data kept as opaque blobs identified globally by name rather than being copied per project. Which projects an agent applies to is controlled by tags, allowing many projects to share an agent without duplication. The plugin is registered via its register method during the MCP::Server::KnowledgeStore::Tools build process, so you only need it if you want simple, tag-based, centralized storage and discovery of agent definitions.

Config::Model::TkUI is a Perl/Tk front end for Config::Model that gives you a graphical tree view and editors to inspect and change structured configuration data such as /etc/X11/xorg.conf using existing Config::Model classes. The left pane shows a navigable tree of nodes, lists and hashes while the right pane presents context aware viewers and editors with support for copy and paste, a searchable tree, an edit wizard that walks important or broken items, external editor integration, annotations and a review of unsaved changes before committing. It remembers font and UI settings, can show diffs for string values when available, and offers filtering options like hiding empty values or showing only custom values to reduce clutter in large configs. Recent releases added a history menu with previous and next location navigation and fixed several corner cases such as hash keys containing literal newlines and a garbled history path. If you already use Config::Model and want a friendly GUI to explore and edit complex configuration trees this module is directly relevant, though the author notes the Tk look and feel could still be improved and welcomes feedback.

MCP::Server::KnowledgeStore::Tools::Spec is a plugin for the MCP knowledge-store tooling that adds document-management commands for project-bound specifications, including listing, searching, fetching, saving, revision listing, marking specs as useful, and archival operations such as archive, restore, purge, and archived-list. It treats each spec as belonging to exactly one required project rather than using tag/untag semantics, so it is a good fit when you need strict project-scoped spec storage and lifecycle operations. You install it by calling its register method from MCP::Server::KnowledgeStore::Tools during server build, and it delegates the actual storage work to the provided store backend. This is the initial release of the module.

This module is a small plugin for the MCP::Server knowledge-store toolkit that adds a ready-made set of CRUD and maintenance tools for managing "skill" records. When registered with an MCP::Server and a backing store it exposes operations to list, search, fetch, save and revision-manage skills, plus tagging, marking a skill as useful, and the usual archive, restore, purge and archived-list actions. It builds on the generic revision-aware toolset and is pre-configured for searchable skill entries that do not use a separate "type" field. Use the register($server, $store) method to attach the tools to your server or let MCP::Server::KnowledgeStore::Tools call it during its normal build process.

MCP::Server::KnowledgeStore::Tools::Memory is a small plugin that wires a set of memory-management tools into an MCP::Server using a KnowledgeStore::Store. It registers commands like list_memories, search_memories, get_memory, save_memory, list_memory_revisions, mark_memory_useful, tag_memory, untag_memory and the archive, restore, purge and archived-list helpers so your server can store, search and manage revisioned memories. The module simply configures the generic Revisioned toolset for searchable memories that include a type field. You normally invoke it via MCP::Server::KnowledgeStore::Tools during server build, but you can also call register($server, $store) directly when integrating memory support into an MCP-based service.

MCP::Server::KnowledgeStore is a lightweight Mojolicious service that gives a network of MCP agents a single shared, append-only store for memories, skills, specs, and agents backed by PostgreSQL, so every agent reads and writes the same canonical data with full revision history preserved. It exposes an authenticated /mcp endpoint and a /health check, uses simple bearer-token authentication where each token name is recorded as the author, and offers environment-driven configuration including a one-time bootstrap token and options to skip migrations or disable irreversible purge operations. There is no user interface bundled; administration or UIs are expected to talk to the store like any other agent, which makes this a focused backend for projects that need a central, auditable knowledge store for cooperating MCP agents.

ExtUtils::PL2Bat is a small utility for turning Perl scripts into Windows batch files so they can be invoked like normal programs from the PATH. You call its pl2bat function with the input script and optional output name and it writes a .bat wrapper that launches perl using configurable argument templates for NT and for older Windows. It can strip common script suffixes, optionally add the -w warnings flag, and will skip or replace an existing generated preamble depending on an update option. The module is adapted from Module::Build and the original pl2bat script and provides a simple, reliable way to make Perl scripts runnable on DOS/Windows systems.

IO::Compress::Zstd is a lightweight Perl interface for creating zstd-compressed data, letting you compress files, filehandles or in-memory buffers either in a single call with the zstd function or via an object that behaves like an output filehandle (IO::Compress::Zstd->new). It supports streaming or one-shot compression, accepts filenames, filehandles, scalar and array references and fileglob patterns, and can write compressed output to files, handles or buffers; common options include compression Level (default 3), Append and AutoClose, and you can start a new compressed stream with newStream. The object provides familiar methods (print, write, syswrite, flush, tell, seek with forward-only seeks, close, autoflush) so it fits into typical IO workflows, and pairing it with IO::Uncompress::UnZstd covers both directions. The module is actively maintained by Paul Marquess and recent updates include modernizing the codebase and raising the minimum supported Perl to 5.8.

Win32API::Console exposes the native Windows console API to Perl so you can allocate or attach consoles, read and write screen buffers, handle low level input events, control cursor, colors, fonts and titles, and work with off‑screen buffers and packed CHAR_INFO data from Perl code. It provides both ANSI and wide (UTF‑16LE) variants and wrapper functions that convert Perl strings as needed, plus structures and constants that mirror the Windows API so Microsoft documentation is mostly applicable. The module is aimed at developers who need direct, fine‑grained console control from Perl, for example CLI tools, GUI programs that need a console, or apps that render directly into the console buffer. It relies on Win32::Console and Win32::API and includes workarounds and emulations for Windows version differences, but the behavior can vary with the XS build and the host OS; known limitations around CP_UTF8 on older Windows are documented. Recent releases added extended screen buffer info functions and improved Unicode and compatibility handling. The code is available under the MIT license.

Termbox::PP is a lightweight, pure-Perl implementation of the Termbox terminal UI library that gives you a small, consistent tb_* API for building text-based interfaces without any XS or external C libraries. It exposes a cell-based back buffer and simple drawing primitives, input event polling for keyboard, mouse and resize events, color and attribute handling including optional extended grapheme cluster and truecolor support, and utility helpers for Unicode and width calculations. The module initializes the terminal (Unix via /dev/tty, Windows via virtual terminal mode with extra Win32 modules), provides tb_init/tb_shutdown, tb_present/tb_clear and tb_print/tb_set_cell for rendering, and tb_poll_event/tb_peek_event for integrating with event loops or select/poll. Because it is written entirely in Perl it is easy to install and inspect, and it includes constants and cell/event objects to keep code readable and portable across terminal environments. The project is actively maintained and considered experimental but usable, and recent releases added configurable runtime debug and trace helpers with TB_DEBUG_LEVEL and a tb_debug_handler in 0.6.0 plus small fixes in 0.6.1 to prevent duplicate installation and tighten strict-mode behavior. If you want to write terminal UIs in Perl without compiling native code, Termbox::PP is a compact, familiar option to evaluate.

IO::Compress::Lzop is a Perl module for creating lzop-compressed data from files, filehandles, in-memory buffers, or lists of files, offering both a simple one-shot function and an object interface for streaming and finer control. You can compress a single file, stream STDIN to STDOUT, write compressed data into a scalar or array, or compress multiple files via globbing, and the OO object behaves like a writable filehandle so you can use print, printf, write, syswrite and flush as usual. Options let you append or truncate output, set archive name and timestamp, start new streams, control autoclose behavior and produce minimal lzop files without checksums, and errors are reported via the $LzopError variable. If you need to read lzop files use the companion IO::Uncompress::UnLzop module.

IO::Compress::Lzma is a Perl module for creating LZMA compressed files or in-memory buffers. It provides a simple functional interface, lzma, for one-shot compression between filenames, filehandles, scalars or arrays, and an object-oriented interface whose objects behave like writable filehandles so you can print, write, flush and close compressed output. The module supports streaming, appending, fileglob mappings and custom LZMA filter objects, and it can start new compressed streams on demand. A few usage notes are that seeking is only allowed forward, BinModeIn is a no-op because input is always read in binary, and you may need to call close explicitly on very old Perls to ensure finalization. For reading LZMA data use the companion IO::Uncompress::UnLzma module.

IO::Compress::Lzf is a lightweight Perl writer for LZF-compressed data that lets you stream or write compressed output to files, filehandles, or in-memory buffers with either a simple one-shot function or a full IO::File-like object. It produces the same file format used by the lzf command-line tool, uses Compress::LZF under the hood, and supports common features such as appending, flushing, seeking forward, and creating new compressed streams while keeping a familiar print/printf/write API. The module is mature and stable and pairs with IO::Uncompress::UnLzf for reading; recent releases have focused on maintenance and CI updates to keep compatibility with newer Perl versions. If you need a direct, Perl-native way to write LZF archives or compress streaming output into LZF files or buffers, this module is a practical choice.

IO::Compress is the umbrella name for Perl's compression libraries that provide reading and writing of compressed streams and zip archives across common formats such as gzip, zlib, bzip2, xz and zstd. The file documented here is only a stub and contains no implementation code, it exists as a compatibility/top-level module while the real functionality lives in the IO::Compress::* and IO::Uncompress::* modules. If you need to compress or uncompress data in Perl, look at the specific modules like IO::Compress::Gzip or IO::Compress::Zip for the actual APIs and features. Recent releases added this stub explicitly and continued active maintenance of the distribution, including raising the minimum supported Perl version to 5.8 and ongoing updates for newer compression formats and bug fixes.

Algorithm::UrataniTakeda implements the Uratani-Takeda multiple-string search algorithm to let you find many patterns in a text quickly by combining ideas from Aho-Corasick and Boyer-Moore, with behavior similar to Commentz-Walter. You construct it with a list of patterns and then either call search with a callback that is invoked for each match, use matches to collect all matches, or use first to get the first match. The callback may return false to stop further searching. This is an experimental implementation that requires Perl 5.26 or later, the initial release is on GitHub, and issues or test cases should be reported there.

Object::Pad is a modern CPAN module that gives Perl a concise, class-and-role syntax built around lexical fields that act as private object members. It supplies class and role keywords, automatic construction with named parameters via field :param, field declarations with reader/writer/mutator/accessor helpers and default or deferred initialisers, methods with a lexical $self and automatic signature parsing, and BUILD and ADJUST phasers for construction-time hooks. The module also supports private lexical methods, anonymous and lexical classes, role composition, and multiple instance representations including native, blessed-hash and magic forms, making it useful both for new pad-based code and for interoperating with classic Perl classes. Object::Pad is a test bed and preview of Perl core's forthcoming class feature so it can be used to write forward-compatible code, but some recently added capabilities are still experimental and may emit warnings or change over time. Use it when you want clean, encapsulated object syntax in Perl and you welcome a feature-rich, actively evolving implementation.

ExtUtils::Typemaps::Magic supplies a T_MAGIC typemap for XS authors that acts as a drop-in replacement for T_PTROBJ but keeps the underlying C pointer out of the Perl-visible SV by storing it in attached magic. That makes the pointer invisible to pure-Perl code and prevents it from being serialized and deserialized, which is usually desirable because such pointers would not be valid after deserialization. You bring it into your build by merging the typemap into your project's typemap or by embedding it at build time, and it includes related helpers such as T_MAGICBUF. You still need to provide a DESTROY method to free the native buffer and this approach is not automatically safe across thread cloning. The recent 0.010 release added *_magic and *_arg extra variables to input maps to give you more flexible argument handling.

Crypt::Passphrase::Linux is an encoder plugin for Crypt::Passphrase that produces and verifies password hashes in the same formats used by Linux crypt, making it easy to work with sha512, sha256, md5, apache_md5 and traditional DES password entries. You can choose the hash type and tune the work factor by setting rounds, which defaults to 656000 and is ignored for DES, and the module also accepts legacy crypt values so existing hashes keep working. It integrates simply via Crypt::Passphrase->new(encoder => { module => 'Linux', type => 'sha512', rounds => 656_000 }). The current release switched salt encoding to crypt64 and added DES support.

Compress::Raw::Lzma is a low‑level Perl wrapper around the liblzma library that gives direct, in‑memory access to LZMA/XZ compression and decompression. It provides encoder and decoder classes for easy, alone, stream and raw modes so you can compress or decompress data either in a single call or streamed in chunks. The interface is buffer oriented and built around code and flush methods with options to control appending, buffer size, memory limits and integrity checks. You can build custom filter chains including LZMA1/LZMA2, BCJ filters for executables and delta filters, set dictionaries and tweak compression presets and match finders for fine tuned performance. The module also exports the usual status constants and version reporting functions. It is primarily intended as the backend for IO::Compress::Lzma, IO::Compress::Xz and related modules but is perfectly usable directly when you need precise, low‑level control over compression behavior.

Compress::Raw::Bzip2 provides a thin, low-level Perl binding to the libbzip2 compression library so you can perform in-memory bzip2 compression and decompression directly from Perl. It exposes compressor and decompressor objects with options for block size, work factor, append or consume behavior, and memory-limiting decompression, and it returns bzip2-style status codes for fine-grained control. The module also exports bzip2 constants and a function to report the underlying library version. It is the foundation used by the higher-level IO::Compress::Bzip2 and IO::Uncompress::Bunzip2 modules, so use it when you need direct, efficient access to libbzip2 features and control, and use the IO::Compress wrappers when you prefer simpler file or stream handling.

Compress::Raw::Zlib is a thin, low level Perl binding to the zlib or zlib-ng libraries that gives you direct control over in memory compression and decompression via Deflate and Inflate objects, exposing options such as compression level, window bits, dictionaries, buffer sizing, append behavior and checksum tracking with crc32 and adler32. The module returns native zlib status codes so you can manage streaming, flushing, resetting and tuning of streams, and it provides helpers to combine checksums and detect whether it was built against zlib or zlib-ng. It also includes a LimitOutput mode to avoid unbounded memory growth when inflating pathological inputs. Choose this module when you need precise, low level access to zlib features or maximum performance, and use the higher level IO::Compress/IO::Uncompress family if you prefer simpler file and archive handling.