CPANscan

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.

EV::Websockets integrates the fast C library libwebsockets with Perl's EV event loop to give you high-performance WebSocket clients and servers from Perl code. You create a Context tied to an EV loop and then connect to remote WebSocket servers, listen for incoming upgrades, or adopt existing sockets, and handle lifecycle events with simple callbacks for connect, message, close, error, pong and drain. It supports TLS, proxy settings, custom headers, flow control, ping/pong and both text and binary payloads, and exposes connection controls like pause/resume, send queue size and clean shutdown. Benchmarks bundled with the distribution show throughput and latency comparable to other native implementations. Note one operational caveat from the author: a Context with no active listeners or connections can keep an internal idle watcher running and interfere with other EV watchers, so create a listener or connection before calling EV::run or destroy the context when it is not in use.

Text::Stencil is a compact, C-accelerated Perl renderer for turning uniform lists or rows of data into formatted text using a single precompiled row template. You write templates with simple placeholders like {0} or {name} plus a rich set of type and transform specifiers for escaping, formatting, truncation, defaults, date and number formats, pluralization and more, and you can chain transforms with pipes for predictable, fast output. It accepts arrayref or hashref rows, supports negative indices and a row counter, can load templates from files or be cloned with small changes, and offers streaming and callback-based rendering as well as sorting and direct-to-filehandle output for large jobs. The implementation is UTF-8 aware, optimized for high throughput and generally several times faster than general-purpose template engines for table and list rendering, but the object is not safe for concurrent renders from multiple threads so create separate instances per thread or serialize access.

String::Redactable is a small Perl utility for wrapping sensitive text so it will not be accidentally exposed when printed, logged, or serialized. You create an object with String::Redactable->new($secret) and ordinary string operations yield a placeholder such as "<redacted string>", while calling to_str_unsafe returns the original value. The module stores an XOR-obfuscated UTF-8 copy of the value using an object-specific key that is not kept with the object, and it uses overloading plus serializer hooks like TO_JSON and STORABLE_freeze to keep the real contents out of common outputs. This is not intended as a bulletproof security layer against determined attackers, but it is a practical way to avoid accidental leaks of passwords and other secrets in logs and dumps. The source is on GitHub and the module is distributed under the Artistic License 2.0.

Legba provides lightweight, globally shared named state slots that let different packages read and write the same values by name and optionally react to changes with watcher callbacks. You can import per-slot accessor functions into a package or use a functional API to get and set slots, and the module can optimize calls made with literal slot names at compile time for very high performance. Watchers are lazy so they add no overhead unless you register them, and there are numeric indices available for the fastest repeated access when names are dynamic. You also get simple access control with reversible locks and permanent freezes, plus advanced hooks for introspection and custom integrations. For thread safety you can store threads::shared variables in slots and after fork children inherit copy-on-write snapshots of slot values. Note that name-based calls using runtime variables and slots added at runtime do not receive the compile-time optimizations.

Amazon::API is a lightweight, generic Perl toolkit for calling AWS services that you can use directly for ad hoc requests or extend by generating service-specific Perl classes from Botocore metadata with the included amazon-api tool. It handles common AWS tasks such as credential discovery or injection, request signing, header and content-type handling, automatic pagination for Botocore-backed calls and optional decoding of JSON or XML responses, and it can create small service subclasses so you only install the APIs you need. For reliable request and response serialization it integrates with generated "shape" classes derived from Botocore metadata, which makes complex payloads easier to build and parse, although serialization edge cases have historically required careful debugging and the module returns raw responses by default on serialization errors unless you opt to raise them. Amazon::API is a pragmatic alternative to larger projects like Paws when you want a more focused or DIY interface for a small set of services and it includes flexible error and debug controls to help troubleshoot calls. A recent release replaced LWP::UserAgent with an included Amazon::API::HTTP::UserAgent and added modern HTTP and SSL dependencies to improve HTTP and TLS handling.