CPANscan

Sidef is a modern scripting language engine you can embed in Perl to parse, compile, optimize and execute Sidef code from your Perl programs, or to compile Sidef into Perl for inspection or high-performance execution. It blends object oriented and functional idioms, offers native arbitrary precision integers, rationals, floats and complex numbers, supports multiple dispatch, pattern matching, lazy evaluation and a full class system, and gives direct access to CPAN modules so you can reuse Perl libraries without glue code. The Sidef module exposes a simple API for running one‑liners, REPL sessions, AST parsing and optimization, and for caching compiled output with an optional DBM-backed cache to speed repeated runs. To build and use it you need the GMP/MPFR/MPC C libraries for numeric support and optionally DB_File or GDBM_File for caching, and you should note the bundled cache is not thread safe and Unicode behavior follows Perl's implementation. If you want a Ruby/Raku-like language that runs on the Perl ecosystem and can be embedded, instrumented and compiled back to Perl, Sidef provides a polished, developer friendly toolset to do that.

CPANSA::DB packages the CPAN Security Advisory reports as a ready-to-use Perl data structure so your code can programmatically read the advisory database. It exposes a single method, db, which returns a hashref containing all advisories, and although it was created for CPAN::Audit any Perl program can use it. Each release also ships a JSON equivalent and includes verifiable artifacts such as GPG signatures and GitHub attestations so you can confirm the archive came from the official source. If you need a simple, authenticated way to consume CPAN security advisories in Perl, this module provides the data and the verification hooks.

Perl::PrereqScanner::NotQuiteLite is a lightweight scanner that inspects Perl source to discover the modules and language features a project needs, classifying them as hard requirements, recommendations, suggestions found inside eval, or modules explicitly excluded with no. It is configurable with a set of parsers and accepts project or installed parser plugins so you can extend detection for nonstandard loaders and keywords, and it can scan files or strings and returns a Context object listing requires, recommends, suggests and noes. It recognizes conditionally loaded modules and some modern Perl features such as say and signatures to help determine a minimum perl version, and it aims to be faster than PPI-based scanners while remaining pure Perl though not as fast as an XS lexer based scanner. Options let you enable parsing of eval blocks, treat block-loaded modules as recommends, ignore paths, and dedupe modules that belong to the same distribution, making it useful when generating cpanfile or auditing dependencies for packaging and CI. The project is mature and actively maintained and the latest release adds support for builtin and experimental class features as well as Feature::Compat::Class, improving detection for newer language constructs.

String::FillCharTemplate provides a tiny, focused utility to populate placeholder characters in a template with characters taken sequentially from an input string. You call fill_char_template(template, string) and each placeholder in the template is replaced by the next character from the input, with any remaining slots padded with spaces so the template layout is preserved. It is ideal for simple tasks like inserting digits into phone numbers, IDs, or other fixed masks without the overhead of Perl formats. The module exposes a single function, is lightweight to use, and is available on CPAN with source on GitHub.

Chandra::EPUB is a lightweight EPUB reader written in Perl that uses the Chandra GUI framework to open and display .epub books. You can start it with a single open call or create a Chandra::EPUB object with options such as file, width, height and title and then call run to show the book in a window. The module loads the EPUB container and extracts chapters, CSS, images and the XHTML body so you can render or process the content. It is useful for adding a simple desktop EPUB viewer to Perl applications and is distributed under the Artistic License 2.0 with bugs tracked via CPAN RT.

Alien::libwebsockets is an Alien-style Perl module that makes the libwebsockets C library easy to use from Perl by either finding a system installation or downloading and building libwebsockets from source for you. It is designed to supply compiler and linker flags to build Perl XS or C extensions, and integrates with ExtUtils::MakeMaker so you can set CCFLAGS and LIBS from Alien::libwebsockets->cflags and ->libs. When it builds from source it enables SSL, zlib, and the permessage-deflate extension, and will also enable libev support if libev development headers are present. The module inherits Alien::Base behavior and provides a has_extensions method that reports whether permessage-deflate support is present, though that detection is only reliable for its own built "share" installs and not for some system-installed libraries. If you need a straightforward way to ensure libwebsockets is available to your Perl build process, this module handles the discovery and optional build for you.

Pod::Markdown::Githubert converts Perl POD documents into GitHub-flavored Markdown and is a subclass of Pod::Markdown so it follows that API while adding GitHub-aware improvements. It rewrites internal L</...> links to match GitHub heading ids, lets you embed literal GitHub Markdown with =for github-markdown blocks, and redirects perlXYZ links to perldoc.perl.org so Perl manual pages resolve correctly. Verbatim POD is emitted as fenced ``` code blocks with normalized indentation and robust handling of nested blocks and backticks. You can enable syntax highlighting globally or per block via the new hl_language setting or =for highlighter language=... markers and the module also escapes dollar signs and prefers asterisks for italics to avoid GitHub rendering quirks. The module requires a recent Pod::Markdown and the 0.05 release added the hl_language constructor parameter and method.

Pod::Simple is a stable, widely used Perl library for reading and parsing Pod, the lightweight documentation format used by Perl and CPAN modules. It provides a parsing framework you can use directly with ready-made formatters such as Pod::Simple::XHTML or subclass to write your own formatter to emit text, HTML, XML, RTF or other outputs. The parser handles encoding declarations and includes options to treat input as characters, to strip or normalize verbatim indentation, to expand tabs, and to collect parse errors for reporting, and it offers convenient one-liner helpers like filter() for quick conversions. Note that Pod::Simple does not try to parse Perl code itself so pod-like lines inside ordinary multi-line strings may be treated as pod unless they are protected by indentation or here-doc syntax. The module is actively maintained on GitHub and recent updates improve URL and manpage linking, add better fallbacks when HTML::Entities is not available, and fix Unicode encoding in URL fragments.

mdee is a terminal-based, multi-column Markdown viewer that makes Markdown easier to read by applying syntax highlighting, hiding markup characters by default, and presenting content in clean, paged columns. It wraps long list items intelligently, aligns Markdown tables into neat columns, supports themes and light or dark modes, and can produce multi-column, n-up paged output or simpler pager or stdout views for piping. Links can be converted to clickable OSC 8 hyperlinks when the terminal and pager support them. mdee is implemented as a small Bash pipeline that combines App::Greple for highlighting with tools like ansifold, ansicolumn, and nup, and it exposes many options to tweak folding, table handling, colors, and layout. It is designed for reading plain Markdown and LLM-generated text rather than as a full renderer so it does not reflow paragraphs and has known limits such as no multi-line emphasis, limited link styles, and dependence on terminal and less versions for some features. Installation is available via Homebrew or CPAN.

Langertha is a Perl framework that gives you a single, consistent API for talking to many large language models and local inference servers so you can swap providers without rewriting your code. It wraps chat, streaming, embeddings, transcription and image generation APIs, normalizes response metadata and rate limits, and adds higher-level features like automatic multi-round tool calling, a stateful autonomous agent called Raider, a plugin system, and optional Langfuse observability. You can use it synchronously or with async/await and it supports a wide range of engines from OpenAI, Anthropic and Ollama to Gemini, HuggingFace, vLLM and many self-hosted adapters. The project is still a work in progress but already provides streaming callbacks, iterator and Future-based APIs, model discovery, and helpers to resolve and construct engines for runtime flexibility. In the latest 0.307 release it added an OpenAI-compatible SGLang self-hosted engine and improved module discovery and a Langertha->new_engine helper to make finding and instantiating engine implementations easier.

Chandra::Game::Tetris is a small, playable Tetris implementation built as a module for the Chandra framework. You start it by creating a game object with Chandra::Game::Tetris->new and calling ->run, and it uses familiar controls: arrow keys to move and rotate, down for soft drop and space for hard drop. It is aimed at Perl developers who want a quick, embeddable Tetris demo or a lightweight game component for Chandra-based projects and is released under the Artistic License 2.0.

Graphics::Framebuffer is a Perl library for drawing directly to a Linux console framebuffer that gives you a simple, scriptable way to render pixels, lines, shapes, images and TrueType text without using X11. Its API uses descriptive lower-case parameter names passed as hash references so you can quickly plot pixels, draw boxes, circles, polygons, bezier curves, perform blits and transforms, play animated frames and dump or load images with optional scaling and gradients. The module can use the Imager library and optional C acceleration for faster image work while still running in pure Perl on systems that lack those extras, and it provides an emulation mode so you can develop offscreen or on machines without a framebuffer. This is a console-only tool so it requires a framebuffer device and will not work inside X/Wayland or with proprietary DRM drivers, and the author recommends 24/32 bit color modes for best performance. It also includes convenience features for clipping, masking, alpha and blend modes, basic mouse polling, vertical sync, and TTF layout helpers, and comes with examples and a manual to get you started.

mb::JSON is a compact, dependency-free JSON encoder and decoder for Perl 5.005_03 and later that correctly preserves UTF-8 multibyte strings, making it handy on older Perl installations where JSON::PP or JSON::XS may not be available. It parses JSON text into Perl scalars, arrays and hashes and now also converts Perl data back to JSON UTF-8 byte strings via encode. The module provides singleton Boolean objects mb::JSON::true and mb::JSON::false so JSON true/false values round-trip unambiguously instead of becoming numeric 1 or 0. Output is deterministic because hash keys are sorted and multibyte characters are emitted as UTF-8 rather than forced into \\u escapes. Be aware of a few limitations documented by the author such as lack of surrogate-pair support for \\uXXXX sequences, no detection of circular references during encoding, and stringification of reference types other than arrays and hashes.

Lang::Monkey is a small Perl-packaged implementation of the Monkey programming language that gives you an interactive REPL for trying out Monkey code; install the module and run the mpl command to start experimenting. It is aimed at developers who want a simple, hands-on way to learn or prototype in Monkey and to integrate quick Monkey snippets into Perl-driven workflows. This is the initial 0.01 release by Rajkumar Reddy and was created with h2xs, so expect a minimal, early-stage toolkit focused on the REPL experience. The module is distributed under the same license terms as Perl.

UTF8::R2 is a Perl module that gives you predictable, enterprise-grade UTF‑8 handling without using Perl's internal UTF8 flag, so existing byte-oriented code keeps working while you opt in to codepoint semantics. It provides mb::* subroutines for multibyte operations and a $mb{qr/...} wrapper to build UTF‑8 aware regular expressions, supports multiple UTF‑8 variants including RFC3629, RFC2279 and WTF‑8 plus ja_JP‑optimized forms, and runs on Perl 5.005_03 and later. This makes it useful when you need to avoid mojibake, preserve octet behavior for legacy scripts, and still perform correct Unicode-aware matching and slicing. Note that it only supports UTF‑8 encodings and requires using the mb:: functions or $mb{qr/...} form to get codepoint behavior rather than changing Perl's defaults.

Linux::Clone brings low-level Linux process and namespace syscalls into Perl so you can create and manage things like new network, PID, user and mount namespaces, call clone to spawn processes with specific CLONE flags, join namespaces with setns, perform pivot_root, and run kcmp to compare kernel resources. It is handy when you want to script namespace experiments, isolate network interfaces, make per-process bind mounts, or inspect kernel relationships from Perl, and it includes a convenience configure_loopback helper plus several ioctl and CLONE constants. The clone interface is deliberately low level and can confuse Perl and libc state so it should be used with care and you should avoid VM or VFORK-like flags; a few clone/KCMP features are only available when matching kernel headers are present and some clone options remain unimplemented. Recent updates cleaned up kcmp handling and added the configure_loopback helper along with extra CLONE and ioctl symbols.

Business::UPS is a lightweight Perl module for interacting with UPS services from scripts and web apps, offering two main helpers: a now-deprecated getUPS function that once returned simple rate quotes and a UPStrack function that fetches package tracking details. The rate-quoting endpoint used by getUPS has been retired by UPS so calls will fail and the function will be removed in a future release, and you should instead use Business::Shipping or the official UPS Rating API for live rates. UPStrack remains useful and returns a hash of delivery information such as current status, service type, weight, delivery date, signed-by and a nested Scanning structure with individual activity records, and it dies on error so callers should wrap it in eval. The module targets Perl 5.014 or later and depends on LWP::UserAgent and JSON::PP, is free to redistribute under the same terms as Perl, and is not endorsed by UPS.

HTTP::Handy is a tiny, single-file, zero-dependency HTTP/1.0 server for Perl 5.5.3 and later that implements a useful subset of the PSGI interface so you can run web apps without installing extra modules. You start it with HTTP::Handy->run(app => $app, port => 8080) and it provides convenience utilities for serving static files, parsing query and POST bodies, detecting MIME types, building HTML, JSON, text and redirect responses, recognizing htmx requests, and logging access in LTSV format while auto-creating a simple directory layout for logs and htdocs. It includes a lightweight in-memory psgi.input object to support older Perls and is ideal for local tools, demos, and rapid development where simplicity and portability matter. It is intentionally minimal and not designed for production because it is single-threaded, supports only HTTP/1.0 and GET/POST, fully buffers request bodies, and does not provide HTTPS or hardening. If you need full PSGI features or a production-ready server you can port your app to Plack or put an HTTPS reverse proxy in front of HTTP::Handy.

Music::SimpleDrumMachine is a lightweight Perl module for programmatically producing simple 16th-note MIDI drum phrases, useful if you want to sketch beats or drive a MIDI synth from Perl. It gives you a configurable phrase length, tempo, MIDI channel (with an option for multi‑timbral output), and division settings so the default 16th-note grid can be changed, and it ships with common drum mappings like kick, snare, hi-hat and crash. Patterns are supplied as code references called parts, so you can plug in custom beat logic and also provide half-bar fills, and it can send output to a named MIDI port with adjustable pulses‑per‑quarter settings. If you need a small, easy-to-use drum sequencer in Perl for quick prototyping or driving hardware, this module is a good fit.

DB::Handy is a self-contained, pure-Perl relational database engine that stores tables as fixed‑length binary files and presents a familiar DBI-like API so you can use connect, prepare, execute and the usual fetch helpers without a separate server or any XS/C dependencies. It runs on Perl 5.005_03 or later and implements a robust subset of SQL including JOINs, subqueries, aggregates, ORDER BY, LIMIT/OFFSET and set operations, plus single-column binary indexes for fast equality and range lookups, making it a convenient lightweight option for embedding structured storage in scripts or small applications. The module is intentionally simple and portable so it has important limitations to be aware of such as no transaction support, no BLOB/CLOB types, VARCHAR values always occupying 255 bytes on disk, no enforced foreign keys or views, no window functions and only single-column indexes. The API mirrors DBI conventions closely so porting small DBI-based code is straightforward, and recent releases improved documentation and tests, added multilingual SQL cheat sheets and tightened compatibility with older Perl releases.

LTSV::LINQ is a Pure Perl library that gives you a fluent, LINQ-like query API for LTSV log files and in-memory arrays, letting you filter, transform, aggregate, group, join and sort records with chainable methods and lazy evaluation. It reads LTSV lines as hashrefs and supports a concise DSL for simple key=value filters or code references for complex logic, plus about 60 LINQ-style operators including distinct, union, groupby, join, orderby (string and numeric variants), and many terminal operations like ToArray, Count and Sum. The iterator-based design makes typical pipelines streaming and memory efficient so you can scan very large logs without loading them, while operations that require global knowledge such as OrderBy, GroupBy or Join do materialize data and will use memory. Be aware that query objects are single-pass iterators so you should snapshot with ToArray when you need multiple passes, and FromLTSV holds the file handle open until the iterator finishes which can matter if you open many files concurrently. The module is pure Perl with no XS dependencies, runs on Perl 5.005_03 and later, and includes examples and cheat sheets to help you adopt LINQ-style log analysis in Perl.

AWS::Lambda makes it straightforward to run Perl code on AWS Lambda by providing a custom runtime and ready-made artifacts so you can just drop in a handler.pl, zip it or build a container image and deploy. The distribution offers prebuilt Amazon Linux 2023 runtime layers, optional Paws (Perl AWS SDK) layers, downloadable zip archives and Docker images, plus helper routines to print the correct layer ARNs, so you can focus on your code rather than runtime plumbing. It supports streaming responses and AWS X‑Ray tracing, comes with a set of commonly used Perl modules preinstalled, and lets you create custom module layers for additional dependencies. Local testing is supported via Docker and the Lambda Runtime Interface Emulator, legacy Amazon Linux and AL2 layers remain available for backward compatibility but are no longer maintained, and recent releases keep the runtime current with the latest Perl releases and dependency updates including support for the 5.42.x series and key JSON and SSL library bumps.

Mouse is a lightweight, Moose-compatible object system for Perl 5 that gives you Moose-style class and role syntax, attributes, method modifiers, type constraints and the familiar meta API but with far lower startup cost and minimal runtime dependencies. It lets you declare attributes with has (including readers, writers, defaults, lazy builders, coercions and delegation), add before/after/around modifiers, consume roles, and call make_immutable for faster objects while remaining close enough to Moose that you can usually swap one for the other. Mouse ships with a pure-Perl implementation and an optional XS backend for extra speed and works well in scripts or command-line tools where startup time or dependency bloat matters. It is intentionally a subset of Moose, so if you need more advanced MooseX extensions you should move to Moose, and there are helpers like Any::Moose to smooth compatibility. The latest release fixes a corner case converting floating point numbers to strings when using quadmath-enabled Perls.

PAGI, the Perl Asynchronous Gateway Interface, is a modern async successor to PSGI that defines a standard way for async-capable Perl web servers, frameworks, and applications to interoperate. It specifies an async application signature that receives a scope plus receive and send callbacks and it supports HTTP/1.1, WebSocket, and Server-Sent Events so you can build both request/response handlers and persistent connections. The distribution ships a reference PAGI::Server, lifecycle helpers, request and protocol wrappers, routers, middleware, and example apps to help you get started. The core spec and the reference server are intended to be stable while many convenience modules remain under active development and may change between releases. PAGI requires Perl 5.18 or newer and relies on IO::Async and Future::AsyncAwait. This is beta software so for production use you should run the server behind a reverse proxy and expect non-spec helpers to evolve. If you want to write or run modern asynchronous web services in Perl and prefer an explicit async interface, PAGI is worth a look.

App::CdUtils is a small collection of command-line helpers that make directory navigation more precise and scriptable. The distribution bundles several backend utilities for common tasks such as jumping to sibling directories, moving to the previous or next sibling, navigating to a specific path part, resolving a target directory and displaying a directory tree, so you can integrate smarter cd behavior into shell wrappers or scripts. It is aimed at shell users and developers who want reliable, reusable building blocks for programmatic directory changes and completion, and it is available on CPAN with source on GitHub.

Razor2::Client::Agent is the command line front end for Vipul's Razor collaborative spam detection system and powers the razor-check, razor-report, razor-revoke, and razor-admin tools. It handles configuration and logging, parses mbox and single-message input, applies local whitelist and mailing-list checks, finds and contacts Razor servers, and performs actions such as checking messages against the Razor catalogue, reporting spam, revoking reports, and basic administrative tasks like creating the razorhome and registering identities. The module is normally used via the supplied programs rather than called directly and supports backgrounding of reports, automatic identity registration when needed, and taint-safe startup. Return codes indicate match, no match, or error so it can be integrated into mail filtering pipelines. Use this if you need a ready-made command-line client for Razor or a foundation for building Razor-aware mail tools.

Net::Jabber::Bot is a Moo-based Perl module that makes building XMPP/Jabber chat bots straightforward by hiding protocol details and enforcing sensible safety defaults so you can focus on your bot logic. You configure connection and behavior, provide a message handler and an optional background task, and the module takes care of joining rooms, parsing messages, rate limiting, message chunking, hourly caps, presence and roster management, and optional auto-accept of subscriptions. It supports TLS/GTalk style connections, per-forum aliases and trigger strings, sending group or personal messages, changing status and forum subjects, and can auto-split or block oversized messages to avoid flooding servers. Recent releases improved robustness by fixing self-message detection in multiuser chats, repairing silent-reconnect behavior, and correcting message chunking edge cases, along with broader test coverage and stability fixes. Note that a JoinForum call currently lacks explicit join-failure reporting, so you may want to handle that edge case in your code.

Module::Metadata extracts useful information from Perl module files (.pm) so tools and authors can inspect packages without fully loading them. It uses mostly static analysis but will evaluate $VERSION assignments to report accurate versions. You can build an object from a filename, filehandle, or module name and optionally collect and decode POD sections. The module can find modules in @INC, list packages inside a file, check if a package is PAUSE indexable, and produce CPAN META "provides" data or a directory-to-package version map for packaging and release workflows. It also handles common byte order marks and encoding declarations making it practical for use in build systems, CPAN tooling, and other automation that needs reliable module metadata.

Data::HashMap::Shared implements file-backed, type-specialized hash maps in shared memory to enable fast, efficient multiprocess data sharing on Linux. It uses a futex-based read-write lock with a lock-free fast read path and provides lock-free atomic counters for increments and compare-and-swap on integer variants. Multiple typed variants cover integer and string keys and values, and features include optional LRU eviction, per-key TTLs, sharding across multiple files, an arena allocator for string storage, and both keyword and method APIs with batch operations and independent cursors. It also supplies atomic remove-and-return primitives useful for work queues, diagnostic stats, pre-reserve and unlink operations. Requirements and caveats are that it is Linux-only and requires 64-bit Perl, stale-lock recovery depends on a shared PID namespace so cross-container use is not supported, and data may need to be cleared after recovering from a writer crash for safety-critical applications. Overall it is a strong choice when you need a high-performance mmap-backed shared hash for cross-process caching, counters, or work queues on a single Linux host.

File::Raw is a Perl module that speeds up common file tasks by calling the operating system directly rather than using PerlIO, making reads, writes and metadata operations much faster. It gives simple, familiar helpers such as slurp, spew, append and atomic_spew, as well as line-oriented tools like each_line, lines_iter, head and tail, memory-mapped access for zero-copy reading, and fast copy/move/unlink and directory utilities. The module also provides a cached stat facility to cut down on repeated syscalls, predicate-based line filtering, hooks for transforming data on read or write, and platform-tuned optimizations such as sendfile and copyfile for native performance. If you work with large files, do a lot of file metadata checks, need memory-efficient line processing, or want atomic writes, File::Raw is a practical way to get noticeably better IO performance in Perl.