[[Interface::library]]

Slixmpp: Has the goal is to be process threadless.

Slln: slln (an abbreviation for "serialization") is focused on the generic serialization of objects (i.e., object persistence) in the C++ programming language, from PODs to STL containers to user-defined Serializable types. By taking advantage of relatively new, advanced C++ techniques s11n makes this formerly difficult task considerably easier.

Smart Pointers: The smart_ptr class can be used with STL containers to create containers of smart pointers, moreover it can be used to create a container of abstract based objects via smart_ptr. In general, smart_ptr is faster than boost::shared_ptr. When used with STL containers, the smart pointer is faster than the boost pointer containers. More importantly, the interface for an STL container of smart_ptr is a 100% compatible with STL containers, which is not the case with the boost pointer containers. smart_ptr has a policy that allows it to synchronize access to both the smart pointer and the pointee. The smart_ptr has been compiled and tested on VC++ 6.0, 7.1, 8.0, GNU 3.x, Borland 5.5, and Comeau 4.3.

Smarteiffel: SmartEiffel is a research and free software project that provides the Eiffel community with a mature and free compiler, an extensive and entirely object-oriented class library and a set of Eiffel-specific tools needed for a complete development environment, as an Eiffel-level symbolic debugger or a documentation tool.

Social: GNU social gives you a powerful social network that is federated. GNU social is a social networking platform. It helps people in a community, company or group to exchange short status updates, do polls, announce events, or other social activities (and you can add more!). Users can choose which people to "follow" and receive only their friends' or colleagues' status messages. It provides a similar service to proprietary social network sites, but is much more awesome. With a little work, status messages can be sent to mobile phones, instant messenger programs (using XMPP), and specially-designed desktop clients that support the Twitter API. GNU social supports an open standard called OStatus that lets users in different networks follow each other. It enables a distributed social network spread all across the Web.

SocksiPy: This module was designed to allow developers of Python software that uses the Internet or another TCP/IP-based network to add support for connection through a SOCKS proxy server with as much ease as possible.

Sofia-sip: Sofia-SIP is a SIP User-Agent library, compliant with the IETF RFC3261 specification. It can be used as a building block for SIP client software for uses such as VoIP, IM, and many other real-time and person-to-person communication services. The primary target platform for Sofia-SIP is GNU/Linux. Sofia-SIP is based on a SIP stack developed at the Nokia Research Center.

Soya: Soya 3D is a very high level 3D engine for Python. Soya aims at being to 3D what Python is to programming : fast to learn, easy to use, while keeping good performances ! Soya is Free Software, under the GNU GPL. Soya's goal #1 is to allow to develop as rapidly as possible 3D games and other 3D apps. Soya's goal #2 is to be as easy as possible to learn. In particular, Soya is used in the games Slune and Balazar Brother.

Speechd-el: 'speechd-el' is a complete speech output system for Emacs. It provides an Emacs Lisp library for easy access to a selected subset of Speech Dispatcher functions, and, using that library, provides speech support for Emacs to Emacs users. It can make Emacs either a completely speech enabled application suitable for visually impaired users or it can speak only in certain situations or when asked. Users need not customize each particular Emacs function to make it speak; most built-in and external Emacs packages produce speech output immediately, without any special support. Almost no change of standard Emacs behavior, and no interference with user settings. The package cooperates fully with Speech Dispatcher.

Speex ,: The Speex project aims to build a patent-free voice codec. Unlike codecs like MP3 and Ogg Vorbis, Speex is specially designed for compressing voice at low bit-rates (in the 8-32 kbps/channel range) for applications such as voice over IP (VoIP). Other possible applications include Internet audio streaming at low bit-rate, and archiving of speech data (e.g. voice mail).

Spidr: A versatile Ruby web spidering library that can spider a site, multiple domains, certain links or infinitely. Spidr is designed to be fast and easy to use.

Sprinkles: A library to assist you in making your applications easily support plugins.

Src-highlite

Source-highlight reads source language specifications dynamically, thus it can be easily extended (without recompiling the sources) for handling new languages. It also reads output format specifications dynamically, and thus it can be easily extended (without recompiling the sources) for handling new output formats. The syntax for these specifications is quite easy (take a look at the manual). Source-highlight is a command line program, and it can also be used as a CGI. Notice that Source-highlight can also be used as a formatter (i.e., without highlighting): you can, for instance, format a txt file in HTML (and it will take care of translating special characters, such as, <, >, &). Since version 2.2, source-highlight can also generate cross references; in order to do this it relies on Exuberant Ctags. These are the output formats already supported:

HTML
XHTML
LATEX
TEXINFO
ANSI color escape sequences (you can use this feature with less)
DocBook

These are the input languages (or input formats) already supported (in alphabetical order):

Ada
Autoconf files
C/C++
C#
Bib
Bison
Caml
Changelog
Css
Diff
Flex
Fortran
GLSL
Haxe
Html
ini files
Java
Javascript
KDE desktop files
Latex
Ldap files
Logtalk
Log files
lsm files (Linux Software Map)
Lua
Makefile
M4
ML
Pascal
Perl
PHP
Postscript
Prolog
Properties files
Python
RPM Spec files
Ruby
Scala
Shell
S-Lang
Sql
Tcl
XML
XOrg conf files

StatePy: StatePy is an event driven hierarchical finite state machine library that lets you easily design, build, and analyze state machines. It represents individuals states as classes, and by default uses static transition tables. The tables are simple python dicts maping events, which can be any hashable type, to the next state. Member functions of the state classes are called upon entering, upon exiting, and on every transition.

Stem: Stem is a TorCtl successor, a Python Tor controller with extensions to support path building and various constraints on node and path selection, as well as statistics gathering.

StepTalk: StepTalk is scripting framework which can be used to create scriptable servers or applications. It is language independent; you can use it with any available scripting language that is provided as a separate bundle. StepTalk is the official GNUstep scripting framework.

Stream: Streams are iterables with a pipelining mechanism to enable data-flow programming and easy parallelization.

StringTemplate3: ST (StringTemplate) is a template engine for generating source code, web pages, emails, or any other formatted text output. ST is particularly good at multi-targeted code generators, multiple site skins, and internationalization/localization. It evolved over years of effort developing jGuru.com. ST also generates the Cheeseshop and powers the ANTLR v3 code generator. Its distinguishing characteristic is that it strictly enforces model-view separation unlike other engines.

Sugar Artwork: Sugar provides a simple yet powerful means of engaging young children in the world of learning that is opened up by computing and the Internet. Sugar promotes sharing, collaborative learning, and reflection. Through Sugar's clarity of design, children and their teachers use computation on their own terms; they are free to reshape, reinvent, and reapply both software and content into powerful learning activities. Sugar is a community project; it is based on GNU/Linux. This is the artwork.

Sugar Base: Sugar provides a simple yet powerful means of engaging young children in the world of learning that is opened up by computing and the Internet. Sugar promotes sharing, collaborative learning, and reflection. Through Sugar's clarity of design, children and their teachers use computation on their own terms; they are free to reshape, reinvent, and reapply both software and content into powerful learning activities. Sugar is a community project; it is based on GNU/Linux. This is the library.

Sugar Presence: Sugar provides a simple yet powerful means of engaging young children in the world of learning that is opened up by computing and the Internet. Sugar promotes sharing, collaborative learning, and reflection. Through Sugar's clarity of design, children and their teachers use computation on their own terms; they are free to reshape, reinvent, and reapply both software and content into powerful learning activities. Sugar is a community project; it is based on GNU/Linux.

Sugar Toolkit: Sugar provides a simple yet powerful means of engaging young children in the world of learning that is opened up by computing and the Internet. Sugar promotes sharing, collaborative learning, and reflection. Through Sugar's clarity of design, children and their teachers use computation on their own terms; they are free to reshape, reinvent, and reapply both software and content into powerful learning activities. Sugar is a community project; it is based on GNU/Linux.

Svglib: Svglib is an experimental library for reading SVG files and converting them (to a reasonable degree) to other formats using the free software ReportLab Toolkit. As a package it reads existing SVG files and returns them converted to ReportLab Drawing objects that can be used in a variety of ReportLab-related contexts, e.g. as Platypus Flowable objects or in RML2PDF. As a command-line tool it converts SVG files into PDF ones. Tests include a vast amount of tests from the W3C SVG test suite. This release accesses 199 flags from Wikipedia.org for test purposes.

TA-Lib: TA-Lib is a library of functions for technical analysis of stock market data. It includes a large number of indicators, oscillators and averages, as well as candlestick pattern recognition. It aims to be a reliable implementation of the various algorithms, from the simple to the complex, providing a base for charting, backtesting and trading. The library is written in C and can be called natively from C++ and Java. Perl and python interfaces are provided using SWIG wrappers. (Some interfaces to non-free software are available too.)

TBCI: TBCI provides classes for Vectors, Matrices, etc., and for defining operations on them. It comes with an extensive set of solvers for linear systems and an interface to lapack libraries. It uses the temporary base class idiom, which avoids unnecessary copying of data. The program's templated library of numerical base classes implement basic data structures like complex numbers, dynamic vectors, static vectors, different types of matrices like full matrices, band matrices, sparse matrices, etc. and also include a representation for Tensors and its typical operations like contraction, direct product and multiplication with contraction.

TNT: The Template Numerical Toolkit (TNT) is a collection of interfaces and reference implementations of numerical objects for scientific computing in C++. It defines interfaces for basic data structures, such as multidimensional arrays and sparse matrices, commonly used in numerical applications. Kits goal is to provide reusable software components that address many of the portability and maintenance problems with C++ code.

TOAD C++ GUI Library: The TOAD C++ GUI Library is a set of classes to create graphical user interfaces with the X Window System. While still under development, it aims to be an alternative to other popular GUI libraries in the future by providing innovative features that ease the development process.

TTFQuery

TTFQuery builds on the FontTools package to allow the Python programmer to accomplish a number of tasks:

query the system to find installed fonts
retrieve metadata about any TTF font file (even those not yet installed)
o abstract family type

o proper font name
o glyph outlines

build simple metadata registries for run-time font matching

Tag Manager

Tag Manager is a library and a set of utility programs to help IDE developers implement features such as code completion, calltips, source browsing, etc. It is based on ctags but overcomes a few of its limitations, such as availability as a clean set of library function calls, ability to show argument list for functions and macros, etc. It is GUI independent.

This project is currently undergoing a complete rewrite as per the developer. The new project will be called 'SourceBase.'

TagLib: 'TagLib' is a library for reading and editing the metadata of several popular audio formats. It supports ID3v1 and ID3v2 for MP3 files, Ogg Vorbis comments and ID3 tags, and Vorbis comments in FLAC files. Tests have shown it to be 6 times faster than id3lib and 3 times faster than libvorbisfile at reading tags (CPU time). It supports Unicode. TagLib offers an abstraction layer that makes it easy to ignore the differences between the different file formats and their implementations. It uses KDE-style programming conventions and C++ by default, but it does not link to either Qt or Glib (it has no external dependancies at all) and does provide Glib-style C bindings (currently for the generic API only).

TagPy: TagPy is a set of Python bindings for Scott Wheeler's TagLib. It builds upon Boost.Python, a wrapper generation library which is part of the Boost set of C++ libraries.

Talkfilters: The GNU Talk Filters are filter programs that convert ordinary English text into text that mimics a stereotyped or otherwise humorous dialect. These filters have been in the public domain for many years, but now for the first time they are provided as a single integrated package. The filters include austro, b1ff, brooklyn, chef, cockney, drawl, dubya, fudd, funetak, jethro, jive, kraut, pansy, pirate, postmodern, redneck, valspeak, and warez. Each program reads from standard input and writes to standard output. The package also provides the filters as a C library, so they can be easily embedded in other other programs. Each program reads from standard input and writes to standard output. It also includes a patch to integrate the talk filters with the Pidgin instant messenger program.

TclCurl: 'TclCurl' provides a binding for libcurl. It makes it possible to download and upload files using protocols like FTP, HTTP, HTTPS, LDAP, telnet, dict, gopher, and file.

Tclap: Templatized C++ Command Line Parser is a simple library for parsing command line arguments. It provides a simple, flexible, object-oriented interface to the command line that automates the parsing, USAGE creation, and type casting common with command line handling. However, this library is templatized so the argument class is type independent which avoids identical-except-for-type objects like IntArg, FloatArg, StringArg, etc.

Tclperl: 'Tclperl' allows the execution of Perl code from within a TCL interpreter using one or several embedded Perl interpreters.

Tclpython: 'Tclpython' allows the execution of Python code from within a TCL interpreter using embedded Python interpreters.

Telescope: A highly customizable test library for Lua that allows for declarative tests with nested contexts.

Tempora: Includes ways to measure difference from these objects and to schedule events.

Termcap: Termcap provides a library for using terminals in programs not depending on the terminal type, and a database of known terminal types. New programs doing character-oriented terminal displays should use ncurses instead. Most of this package is also distributed with GNU Emacs(now only dos), but it is available in this separate distribution to make it easier to install as -ltermcap. However, use of termcap is discouraged. Termcap is being phased out in favor of the terminfo-based ncurses library, which contains an emulation of the termcap library routines in addition to an excellent curses implementation.

Tesseract: Tesseract is an optical character recognition (OCR) engine with very high accuracy. It supports many languages, output text formatting, hOCR positional information and page layout analysis. Several image formats are supported through the Leptonica library. It can also detect whether text is monospaced or proportional. This package contains an OCR engine - libtesseract and a command line program - tesseract.

Threads: Threads is a library designed to make threading under C++ simpler. It provides a "pthread" class, with an abstract method called "thread". It also provides classes for mutual exclusion of parallel processes and condition signalling, and a semaphore class that comes in handy when synchronizing constructor and threaded method. The aim of the threads library is to provide a simple, yet powerful means of threading applcations, and to provide shared memory and process scoping to C++ programs.

Throne: Simple ruby library for working with CouchDB.

Tidylib: 'tidylib' is a C library version of the HTML Tidy package, a popular program for validating, correcting, and pretty-printing HTML files.

Timetric: Client library for Timetric (http://timetric.com/).

Tiny SRP library: The Tiny SRP library is a stripped-down version of srp-1.7.1 and openssl-0.9.6 that contains only what is necessary for secure remote passphrase authentication. No other libraries are required. If you already have libsrp installed on both server and client then you don't need this. Tiny SRP is designed for embedded or mini distributions, and is also a quick and easy way to add secure authentication to small client/server projects. Also included is the TSRP protocol, which reduces socket authentication to one function call on each of the client and server.

TinyQ: TinyQ is a stripped down version of Qt designed for use as a backend library and containing only these classes needed for C++ development. It does not depend on X11. It provides the following features in an extremely compact library: UTF8 and ASCII strings, type optimized collections (dictionary, map, cache, vector, list), regular expressions, filesystem access, URL processing, threads, shared library handling, storing and retrieving user settings, date and time handling, DOM & SAX XML parsers, optimized data and text streams, and abstract IO devices.

TinyRML2PDF: 'TinyRML2PDF' creates PDF documents. It can be used as a Python library or as a standalone program. It converts an RML (an XML dialect that defines the precise appearance of a printed document) document into a PDF document. Your existing tools generate an input file that exactly describes the layout of a printed document, and Tiny RML2PDF converts it into PDF. It is intended as an alternative to XSL:FO.

Tinyxml: TinyXML parses an XML document, and builds from that a Document Object Model (DOM) that can be read, modified, and saved. XML stands for "eXtensible Markup Language." It allows you to create your own document markups. Where HTML does a very good job of marking documents for browsers, XML allows you to define any kind of document markup, for example a document that describes a "to do" list for an organizer application. XML is a very structured and convenient format. All those random file formats created to store application data can all be replaced with XML. One parser for everything. TinyXML doesn't parse or use DTDs (Document Type Definitions) or XSLs (eXtensible Stylesheet Language.) There are other parsers out there that are much more fully featured. But they are also much bigger, take longer to set up in your project, have a higher learning curve, and often have a more restrictive license. If you are working with browsers or have more complete XML needs, TinyXML is not the parser for you. There is a newer version called TinyXML-2.

Tokyo Cabinet: Tokyo Cabinet is a library of routines for managing a database. The database is a simple data file containing records, each is a pair of a key and a value. Every key and value is serial bytes with variable length. Both binary data and character string can be used as a key and a value. There is neither concept of data tables nor data types. Records are organized in hash table, B+ tree, or fixed-length array. Tokyo Cabinet is developed as the successor of GDBM and QDBM on the following purposes. They are achieved and Tokyo Cabinet replaces conventional DBM products.

Torque Network Library: The Torque Network Library (TNL) is a robust, secure, easy to use cross-platform C++ networking API designed for high performance simulations and games. The network architecture in TNL has powered some of the best internet multiplayer action games to date.

TrustLet: TrustLet is a project for collecting and analyzing information about trust metrics. It consists of a wiki, software, and a mailing list. Trust metrics has many applications, particularly in online social media.

TuxFighter: Control Tux, the penguin in this Asteroids-like shooter and destroy rectangular enemys. Pick up Power-up's of various effects. Game is written in python/pygame and under GPL License.

Tvmet: This Tiny Vector and Matrix template library uses Meta Templates and Expression Templates (ET) to evaluate results at compile time, thus making it fast for low-end systems. The code produced is similar to hand-coded code, but its quality still depends on the compiler and its version. The dimensions for vectors and matrices are static and bounded at compile time using template arguments.

Twin: Twin is a text-mode window environment. It turns a text terminal into a X11-style display with window manager, terminal windows, and can also serve as display for remote applications. Each terminal window provides the functions of a text-mode GNU/Linux console. Twin runs on the GNU/Linux console, X11, libggi, and itself. It supports multiple simultaneous displays, and can attach/detach each display on the fly.

Txtorcon: Txtorcon is a Twisted-based Python asynchronous controller library for Tor. It includes configuration and state-tracking abstractions (all routers, circuits and streams) and utilties to launch tor, among other things. It is useful to write event-based software in Python that talks to a Tor program.

Typhoeus: Like a modern code version of the mythical beast with 100 serpent heads, Typhoeus runs HTTP requests in parallel while cleanly encapsulating handling logic. To be a little more specific, it's a library for accessing web services in Ruby. It's specifically designed for building RESTful service oriented architectures in Ruby that need to be fast enough to process calls to multiple services within the client's HTTP request/response life cycle. Some of the awesome features are parallel request execution, memoization of request responses (so you don't make the same request multiple times in a single group), built in support for caching responses to memcached (or whatever), and mocking capability baked in. It uses libcurl and libcurl-multi to work this speedy magic. I wrote the c bindings myself so it's yet another Ruby libcurl library, but with some extra awesomeness added in.

Typing: This provides a way for Python scripts to attest that a variable has a given type, according to Python PEP 0484.

UAmobile: WSGIUserAgentMobile is HTTP mobile user agent string parser. It'll be useful in parsing HTTP_USER_AGENT strings of (mainly Japanese) mobile devices.

UDT: UDT is an application level data transport protocol for the emerging distributed data intensive applications over wide area high-speed networks. UDT uses UDP to transfer bulk data and it has its own reliability control and congestion control mechanism. This new protocol is not only for private or QoS-enabled links, but also for shared networks. Furthermore, UDT is also a composable framework that can accommodate various congestion control algorithms.

USTL: This library implements most of the standard C++ library with the goal of minimizing code size of client applications, achieving this goal by factoring out memory management code from the STL container templates into untyped memory block operations and modifying the templates to act only as a type-safety layer. Compared with the SGI STL implementation, shipped with gcc, using this library can reduce C++ overhead by a factor of four.

Unac: 'unac' is a C library and command that removes accents from a string. For instance, the string ?t? will become ete. It provides a command line interface that removes accents from standard input or from a string given as an argument. In the library function and the command, the charset of the input is specified as an argument. The input is converted to UTF-16 using iconv(3), accents are stripped, and the result is converted back to the original charset. The iconv -l command on GNU/Linux will show all charsets supported. It currently has Perl, PHP3, and PHP4 interfaces, and is Unicode-3.2 compatible.

Uri: 'uri' is a library that analyses URIs and transform them. It is designed to be fast and occupy as little memory as possible. The basic function of this library is to transform a URI into a structure with one field for each component of the URI and vice versa.

VSOFont: VSOFont is a small library used to draw very simple and fast user-definable 2D vector fonts in OpenGL applications. It was written after the author found GLUT's fonts to be too expensive to render.

Vala: Vala is a new programming language that aims to bring modern programming language features to GNOME developers without imposing any additional runtime requirements, and without using a different ABI compared to applications and libraries written in C.

Velocity: VELOCITY offers an extension of the standard C stream processing features. It adds easy tokenizing features and very easy substring mangling, all written, without requiring the user to utilize abstract interfaces.

Vely: Vely is a free open source framework for rapid building of server-side applications. Its goal is maximum performance and simplicity. Vely is well-suited for both web development and command-line applications. It works by generating C code from statements embedded in C code. Run Hello World in minutes.

Verbiste: Verbiste is a French conjugation system implemented as a C++ library, a GNOME applet, and two command-line tools. It can conjugate verbs and analyze conjugated verbs to determine their mode, tense, and person. The knowledge base contains over 6800 verbs.

Vevo: 'vevo' is a library fopr writing realtime video processing plugins. It gives programmers the ability to write simple 'plugin' video processors in C or C++ and link them dynamically with a range of software packages (called hosts). It should be possible for any host and any plugin to communicate through this interface. This lets those who design plugins develop video processing algorithms without having to resolve interface problems, and lets users share the plugins among a greater set of programs and gives them the ability to control at least some aspects of the features they want.

Visualization Library

Visualization Library can be especially useful in the following areas:

3D/2D Scientific Visualization
Virtual Reality
Augmented Reality
Visual Simulation
Data Visualization
Presentations
Multimedia applications
Special effects
3D/2D games

Visualization Library is a 3D/2D graphics middleware and not a 3D engine or a game engine, it is intended to be the base upon which such applications (among many others) can be developed.

Vnu: Validator.nu is a tool for validating HTML files. It can be used from the command line, deployed as a web-based service, or integrated into a number of popular build tools.

Vstr: 'Vstr' is a string library for C designed for network communication. Its design uses chunks of ptr+length data, so adding, substituting, and deleting data are all fast operations. It can also do automatic referencing for mmap() areas of memory. Shortcut APIs are included to mmap() a file into a Vstr string, and read()/write() data to/from a Vstr string. Another feature is a POSIX and ISO 9899:1999 compliant printf() like function, which can be extended with user supplied formatters that are gcc warning compatible. The total API is over 140 functions, but laid out in a easy to remember manner, including data parsing functions, a non-destructive split() function, and conversion functions (among others).

Vte: VTE is a library (libvte) implementing a terminal emulator widget for GTK+, and a minimal sample application (vte) using that. Vte is mainly used in gnome-terminal, but can also be used to embed a console/terminal in games, editors, IDEs, etc.

WBXML Library: The WBXML Library is a C library for handling WBXML (Wireless Binary XML) documents. It consists of a WBXML Parser (with a SAX like interface), a generic WBXML Encoder, and an internal representation of the document (WBXMLTree).

Wayland: Wayland is a communication protocol that specifies the communication between a display server and its clients. A display server using the Wayland protocol is called a Wayland compositor, because it additionally performs the task of a compositing window manager. The aim of Wayland is replacing the X Window System with a modern, secure, and simpler windowing system. As part of its efforts, the Wayland project also develops a reference implementation of a Wayland compositor called Weston. Major desktops such as KDE and GNOME have implemented their own Wayland compositors.

Wb

WB is a disk based, sorted associative array (B-tree) library for SCM. Using WB, large databases can be created and managed from SCM. Rather than being implemented via hashing, WB uses B-trees, which are optimized for using the minimum number of disk operations. Functions are provided to:

create, destroy, open and close disk-files and associative arrays;
insert, delete, retrieve, find next, and find previous (with respect to dictionary order of keys);
apply functions, delete, or modify values over a range of consecutive key values.

WB is thread safe (so long as HAND structures are not shared between threads). The `put' and `rem' operations allow associations to be used for thread mutexs.

Weather forecast from weather api: Python library shows the current weather and weather forecast - hour-by-hour and daily out to 30 days. It retrieves the latest weather information updated every 10 minutes and convert the format into easy-to-use output. You will need your API key which you can get for free from the website. You can choose both metric and imperial units.

Web of Life: An isometric game with C++ and SDL. Your beings should survive fighting with other beings, reproducing to make a massive attack and eating your opponent. But sometimes you will have to eat some of your own live beings so that others could stay alive, well it's life.

WebChuan: WebChuan is a set of libraries and tools for getting and parsing web pages of website. It is written in Python, based on Twisted and lxml. It is inspired by GStreamer. WebChuan is designed to be back-end of web-bot, it is easy to use, powerful, flexible, reusable and efficient.

Webbase: 'Webbase' is an Internet crawler. It crawls the Web to get documents, stores them locally, and builds a full text MySQL database with them. It can also visit sites regularly to make sure the document is still there and update it if it changes. The database uses the local copies of documents to build a searchable index.

Webkitgtk: WebKitGTK is a WebKit port that provides a GTK API wrapper around WebKit. By its very nature, it is suitable for projects requiring any kind of web integration, from hybrid HTML/CSS applications to full-fledged web browsers. This is the rendering engine of GNOME Web. This package is developed within the official WebKit SVN.

Websocket4j: GNU WebSocket4J is a WebSocket protocol (https://tools.ietf.org/html/rfc6455) implementation in Java. It allows you to build Web applications that interact with applications running in a JVM. GNU WebSocket4J implements both server and client side of the protocol, so it can be used to build both WebSocket servers and clients.

Whtlist: Want to make sure that a string includes only certain characters? Create a whitelist. Want to make sure that a string absolutely does not include certain characters? Create a blacklist. Both are easy to do with this simple function and structure.

WikiAccess Library: WikiAccess is a library, that provides access to MediaWiki-based wiki sites.

Wikitools: A Python package for interacting with a MediaWiki wiki using the MediaWiki API. Designed for MediaWiki version 1.15 and higher, should work on 1.13, older versions may have bugs. The edit-API must be enabled on the site to use editing features.

Willows TWIN 2: The Willows TWIN libraries are both a set of native platform libraries and an emulator program to emulate the Microsoft Win32 API. The emulator program allows executing Windows binary programs on supported Unix platforms, on native Intel x86 processors, and through the built-in instruction set interpreter. The native libraries allow programmers to natively build Win32 and MFC applications from source code.

Wine: Wine lets you run Windows programs on GNU/Linux, OS X and BSD by reimplementing the Windows libraries. Warning: some GNU/Linux distributions recommend installing the non-free Microsoft fonts when installing Wine through a package manager. To fix this, you can install it with the apt-get install --no-install-recommends wine command.

Wireguard: WireGuard is a virtual private network software. It is built in to the Linux (and linux-libre) kernel by default. It intends to be faster and simpler than IPSec and OpenVPN. While initially released for the Linux kernel, it is now a cross-platform project. Some users consider WireGuard to already be the most secure and easiest to use among all of the VPN solutions.

Wkhtmltopdf: wkhtmltodpf is a utility for converting local or remote web pages to image or PDF format. This can be done without access to a desktop environment, for example from the command line on a remote server. A C library implementation (libwkthmltox) is also available.

WolfCrypt: wolfCrypt is a highly configurable cryptographic library designed for embedded systems and IoT Devices. wolfCrypt is FIPS certified on multiple operating systems, and wolfSSL is always adding more OS's to that list.

Wolfssl: wolfSSL is an embedded SSL/TLS software library designed for resource constrained environments. wolfSSL has implemented the Secure Sockets Layer (SSLv3 only) and Transport Layer Security (TLSv1,TLSv1.1, TLSv1.2, and TLSv1.3). wolfSSL offers a highly configurable list of features. Dependant upon functionality and speed requirements, wolfSSL can take up as little as 21k on your device. wolfSSL's wolfCrypt module is FIPS certified if you need a FIPS solution.

WrapText: WrapText.c is a simple text wrapping function. It supports a maximum line width and two prefix strings. One for the first line and another for the remaining lines. It uses a naive, greedy to fit the most words possible on the current line. If a word is too large for any line, it gets stuffed on a line by itself.

WuGeo: WuGeo is a Python library to draw points on world maps, using latitude and longitude. Maps have to be created with Miller Projection (aka cylindrical projection).

WxWidgets: WxWidgets (previously wxWindows) is a class library for compiling graphical C++ programs on a range of different platforms. It defines a common API across platforms, but uses the native graphical user interface (GUI) on each platform, so your program has the platform's native look and feel. It comes with bindings for several other languages, of which wxPython is the most complete.

Wyatt-netsuite: Interface plugin for connection Netsuite to wyatt communications base.

XFA: The XFA library implements an API that can be used to create NFA (either programmatically or from regular expressions) and to convert them in the minimal equivalent DFA. The XFA library only requirement is an ANSI C compiler, and this makes it portable virtually over every system. The complexity of the graphs that are treatable with XFA is only limited by the amount of memory available on the machine.

XML Security Library: XML Security Library is a C library based on LibXML2. The library supports major XML security standards, including XML Signature, XML Encryption, Canonical XML, and Exclusive Canonical XML (the latter two were included in LibXML2).

XML Twig: XML::Twig is built on top of XML::Parser. It is designed to process XML efficiently, with a tree-oriented interface that builds the tree only for parts of the documents. A flush method allows dumping of a completely processed sub-document to be printed, thus allowing processing of documents of any size. It has many convenient methods to simplify XML processing. A complete tutorial is available from the home page.

XML2CSV-Generic-Converter: Java XML to CSV (XML2CSV) generic conversion facility. I made it in order to extract data from big XML files and gather them in files more easily opened with a spreadsheet. It is packaged as an auto executable Jar for convenient command line execution but might as well be interfaced directly by a Java class as part of a larger software. It handles attributes, repeated elements, and so on, and produces results which level up with what spreadsheets generate when they import native XML (at least in its most extensive execution mode).

XOSD: XOSD displays text on your screen, sounds simple right? The difference is it is unmanaged and shaped, so it appears transparent. This gives the effect of an On Screen Display, like your TV/VCR etc. It also contains an XMMS plugin and a simple example program that can display system logs overlaid on your desktop.

XRecord: XRecord is an Object-Relational Mapper - a library which provides an object interface to databases. Tables are represented as classes, columns are attributes, and rows of data are class instances. If you used Python for developing database applications you may have come across one or more ORMs.

XZ: XZ Utils consist of several components: liblzma is a compression library with API similar to that of zlib. xz is a command line tool with syntax similar to that of gzip. xzdec is a decompression-only tool smaller than the full-featured xz tool. A set of shell scripts (xzgrep, xzdiff, etc.) have been adapted from gzip to ease viewing, grepping, and comparing compressed files. Emulation of command line tools of LZMA Utils eases transition from LZMA Utils to XZ Utils. While liblzma has a zlib-like API, liblzma doesn't include any file I/O functions. A separate I/O library is planned, which would abstract handling of .gz, .bz2, and .xz files with an easy to use API.

Xapian: Xapian allows developers to add advanced indexing and search facilities to their own applications. It features Unicode 9.0 support, ranked searching, multiple weighting models, relevance feedback, phrase and proximity searching, structured boolean search operators, snowball stemmers, wildcard searching, synonyms, spelling corrections, faceted search, and simultaneous update and searching. It can handle large database files with ease. Projects known to use Xapian include ikiwiki, kiwix, notmuch, mu, sup, and others.

Xidel: Xidel is a command line tool to query data from HTML/XML web pages, JSON-APIs and local files. It implements interpreters for XPath 2, XPath 3, XQuery 1, XQuery 3, JSONiq, CSS selectors and custom pattern matching. XPath and CSS selectors are the most efficient way to select certain elements from XML/HTML documents. JSONiq (with custom extensions) is an easy way to select data from JSON. XQuery is a Turing-complete superset of XPath and allows arbitrary data transformations and the creation of new documents. Pattern matching is for XML/HTML documents what regular expressions are for plaintext, i.e. pattern matching behaves like a regular expression over the space of tags, instead over the space of characters. Xidel implements a kind of internal pipes to pipe HTTP requests from one query to the next, so there is no need to distinguish selecting links and downloading the data referenced by them. Therefore arbitrary complex queries going over arbitrary many pages can be executed with a single call of Xidel.

Xlrd: Xlrd is a Python module for extracting data from Excel spreadsheet files. It can be used to extract data from new and old Excel spreadsheets on any platform. The package itself is pure Python with no dependencies on modules or packages outside the standard Python distribution. It has strong support for Excel dates and is Unicode-aware.

Xls2xml: Xls2xml is a command-line Python script for converting tabular data in Excel spreadsheets into simple XML.

Xmedcon: The Medical Image Conversion library consists of a library, a command line utility, and a GUI interface for converting and manipulating medical images. It can convert between commonly used formats in (freely available) research tools, while preserving medical parameters like patient information, slice orientation, voxel dimension and pixel quantitation. The program can also read unsupported files without compression, print pixel values, or extract/reorder specified images. The library can also be used as a framework for your own image format.

Xorcist: A library to aid comparing strings to see which bits differ using the XOR operation.

Xorn

Xorn is a library to read and write gEDA files, allowing python scripts and GUI's to work on the same objects. Xorn is designed to work with Xi but can be integrated with any application that works on schematics. There is also a command-line utility with two sub-commands:

xorn extract – extract embedded symbols or pixmaps from a schematic
xorn find-symbol-by-pinout – pretty much self-explaining

YAJL Ruby: A streaming JSON parsing and encoding library for Ruby (C bindings to yajl). This gem (although not in gem form just yet) is a C binding to the excellent YAJL JSON parsing and generation library. You can read more info at the projects website http://lloydforge.org/projects/yajl

Yapsy: A simple framework for plugin system developement with as few dependencies as possible. It is designed to offer a set of very lean classes (plugin managers and plugin interfaces) which can easily be customised by decoration or inheritance.

Yarl: This library provides ways for a Python script to make an URL object and only get its parameters, encoded or not.

Yassl

The yaSSL Library version 0.9.9 includes the following:

SSL version 3 and TLS version 1 (client and server)
OpenSSL compatibility layer
MySQL integration
Initial stunnel integration
MD5, SHA-1, HMAC, DES, 3DES, AES, ARC4, RSA, DSS, and DH
Simple API
Interchangeable crypto and certificate libraries
PEM and DER certificate support

Yate- Yet Another Telephony Engine: "YATE" (Yet Another Telephony Engine) is a telephony project that is written in C++ and that will support scripting in various programming languages. It is a next-generation telephony engine; while currently focused on Voice over Internet Protocol (VoIP) and PSTN, its power lies in its ability to be easily extended. Voice, video, data and instant messenging can all be unified under Yate's flexible routing engine, maximizing communications efficiency and minimizing infrastructure costs for businesses.

Yed: Yed is a C software library made of modules (objects) instanceable according to the main paradigms of Object Oriented Programming: incapsulation and data hiding. The library contains objects that handle XML files, FTP connections, filesystem operations, etc. Yed acts only at the C compiler preprocessing level, using particular macros; therefore, using Yed objects is transparent to the compiler, so users do not have to develop additional "translation" tools that have to be run before compiling.

Yet Another JSON Library (YAJL)

Why does the world need another C library for parsing JSON? Good question. In a review of current C JSON parsing libraries I was unable to find one that satisfies my requirements. Those are:

0. written in C
1. portable
2. robust -- as close to "crash proof" as possible
3. data representation independent
4. fast
5. generates verbose, useful error messages including context of where the error occurs in the input text.
6. can parse JSON data off a stream, incrementally
7. simple to use
8. tiny
Numbers 3, 5, 6, and 7 where particularly hard to find, and were what caused me to ultimately create YAJL.

Ygl: Ygl is a two dimensional grpahics programs with a variety of standard X11 routines. Included are most 2D graphics routines, a queue device routine, some query routines, doublebuffering, RGB mode with arbitrary visuals and most window attribute routines.

Zeek: Zeek is a powerful network analysis framework that is much different from the typical IDS you may know. (Zeek is the new name for the long-established Bro system. Note that parts of the system retain the "Bro" name, and it also often appears in the documentation and distributions.) While focusing on network security monitoring, Zeek provides a comprehensive platform for more general network traffic analysis as well. Well grounded in more than 20 years of research, Zeek has successfully bridged the traditional gap between academia and operations since its inception. Today, it is relied upon operationally by both major companies and numerous many educational and scientific institutions for securing their cyberinfrastructure. Zeek was originally developed by Vern Paxson. Robin Sommer now leads the project, jointly with a core team of researchers and developers at the International Computer Science Institute in Berkeley, CA; and the National Center for Supercomputing Applications in Urbana-Champaign, IL.

Zthread: ZThread is an advanced object-oriented threading and synchronization library, implemented in C++. It provides an excellent and powerful abstraction from native threads. It includes interruptable thread objects and several other synchronization control objects and lets you safely terminate threads without the complications of using cancellation handlers or other similar constructs.

Free Software Foundation!

Semantic search

Query log

Navigation menu

Personal tools

Namespaces

Variants

Views

More

Search

Interaction

Navigation

Creation

Print

Tools