YAJL is a small event-driven (SAX-style) JSON parser written in ANSI C, and a
small validating JSON generator.

A collection of contributed works to be used with the m17n library,
mainly additional Indic input methods.

Database that is needed by the m17n library "m17n-lib".

A multilingual text processing library for the C language.
This package contains m17n-* programs.

Small shell script that generates a self-extractable tar.gz archive from a
directory. The resulting file appears as a shell script (many of those
have a .run suffix), and can be launched as is. The archive will then
uncompress itself to a temporary directory and an optional arbitrary
command will be executed (for example an installation script).

This is pretty similar to archives generated with WinZip Self-Extractor in
the Windows world. Makeself archives also include checksums for integrity
self-validation (CRC and/or MD5 checksums).

mbuffer is a replacement for buffer with additional functionality:

- display of I/O speed

- optional use of memory mapped I/O for huge buffers

- multithreaded instead of shared memory IPC

- multivolume support

- autoloader support

- network support

- buffer compatible command line options

Monit is a utility for managing and monitoring processes, files,
directories, and devices on a Unix system. Monit conducts automatic
maintenance and repair and can execute meaningful causal actions in
error situations. For example, monit can start a process if it does
not run, restart a process if it does not respond, and stop a process
if it uses too many resources. You can use monit to monitor files,
directories, and devices for changes, such as time stamp changes,
checksum changes, or size changes. You can even use monit to monitor
remote hosts: monit can ping a remote host and check port connections.

MultiTail lets you view one or multiple files like the original
tail program.

The difference is that it creates multiple windows on your console
(with ncurses). Merging of 2 or even more logfiles is possible.

It can also use colors while displaying the logfiles (through
regular expressions), for faster recognition of what is important
and what not. It can also filter lines (again with regular
expressions). It has interactive menus for editing given regular
expressions and deleting and adding windows. One can also have
windows with the output of shell scripts and other software. When
viewing the output of external software, MultiTail can mimic the
functionality of tools like 'watch' and such.

Newsbeuter is an open-source RSS/Atom feed reader for text terminals. It runs
on Linux, FreeBSD, Mac OS X and other Unix-like operating
systems. Newsbeuter's great configurability and vast number of features make
it a perfect choice for people that need a slick and fast feed reader that can
be completely controlled via keyboard.

These tools allow information about (ogminfo), extraction from
(ogmdemux), creation of (ogmmerge), or the division of (ogmsplit) OGG
media streams. OGM stands for OGG media streams.

PBZIP2 is a parallel implementation of the bzip2 block-sorting file
compressor that uses pthreads and achieves near-linear speedup on SMP
machines.

This module is an the AnyEvent manpage user, you need to make sure that you
use and run a supported event loop.

This module implements a simple, stateless and non-blocking HTTP client. It
supports GET, POST and other request methods, cookies and more, all on a
very low level. It can follow redirects, supports proxies, and
automatically limits the number of connections to the values specified in
the RFC.

It should generally be a "good client" that is enough for most HTTP tasks.
Simple tasks should be simple, but complex tasks should still be possible
as the user retains control over request and response headers.

The caller is responsible for authentication management, cookies (if the
simplistic implementation in this module doesn't suffice), referer and
other high-level protocol details for which this module offers only limited
support.

App::Cmd is intended to make it easy to write complex command-line
applications without having to think about most of the annoying things
usually involved.
For information on how to start using App::Cmd, see App::Cmd::Tutorial.

This module provides a c api for XS modules to hook into the callbacks of
"PL_check".

This module provides a c api for XS modules to hook into the execution of
perl opcodes.

Helper functions for op tree manipulation

Most programming languages have a native 'Boolean' data type. Perl does
not.

Perl has a simple and well known Truth System. The following scalar values
are false:

$false1 = undef;
$false2 = 0;
$false3 = 0.0;
$false4 = '';
$false5 = '0';

Every other scalar value is true.

This module provides basic Boolean support, by defining two special
objects: 'true' and 'false'.

The functions optionaly exported by this module allows you to open URLs in
the user browser.
A set of known commands per OS-name is tested for presence, and the first
one found is executed. With an optional parameter, all known commands are
checked.
The "open_browser" uses the "system()" function to execute the command. If
you want more control, you can get the command with the "open_browser_cmd"
or "open_browser_cmd_all" functions and then use whatever method you want
to execute it.

Capture::Tiny provides a simple, portable way to capture anything sent to
STDOUT or STDERR, regardless of whether it comes from Perl, from XS code or
from an external program. Optionally, output can be teed so that it is
captured while being passed through to the original handles. Yes, it even
works on Windows. Stop guessing which of a dozen capturing modules to use
in any particular situation and just use this one.

This module was heavily inspired by the IO::CaptureOutput manpage, which
provides similar functionality without the ability to tee output and with
more complicated code and API.

#-------------------------------------------------------------------------------
A chained accessor is one that always returns the object when called with
parameters (to set), and the value of the field when called with no arguments.

This module subclasses Class::Accessor in order to provide the same
mk_accessors interface.

"require EXPR" only accepts "Class/Name.pm" style module names, not
"Class::Name". How frustrating! For that, we provide "load_class
'Class::Name'".
It's often useful to test whether a module can be loaded, instead of
throwing an error when it's not available. For that, we provide
"try_load_class 'Class::Name'".
Finally, sometimes we need to know whether a particular class has been
loaded. Asking %%INC is an option, but that will miss inner packages and
any class for which the filename does not correspond to the package name.
For that, we provide "is_class_loaded 'Class::Name'".

Class::XSAccessor implements fast read, write and read/write accessors in
XS. Additionally, it can provide predicates such as "has_foo()" for
testing whether the attribute "foo" is defined in the object. It only
works with objects that are implemented as ordinary hashes.
Class::XSAccessor::Array implements the same interface for objects that
use arrays for their internal representation.

Who doesn't remember the first time they learned to copy and paste, and
generated an exponentially growing text document? Yes, that's right,
clipboards are magical.

With Clipboard.pm, this magic is now trivial to access, in a
cross-platform-consistent API, from your Perl code.