Free portable software for linux

Tao::DBI::st is a Perl module for DBI statements with portable support for named placeholders.

SYNOPSIS

use Tao::DBI qw(dbi_connect dbi_prepare);

$dbh = dbi_connect($args);
$sql = q{UPDATE T set a = :a, b = :b where k = :k};
$stmt = $dbh->prepare($sql);
$rc = $stmt->execute({ k => $k, a => $a, b => $b });

# dbi_prepare() can also be used to create Tao::DBI::st
$stmt = dbi_prepare($sql, { dbh => $dbh });

POCO C++ Libraries project are the next generation C++ class libraries for network-centric applications.

POCO, the C++ Portable Components, is a collection of open source C++ class libraries that simplify and accelerate the development of network-centric, portable applications in C++. The libraries integrate perfectly with the C++ Standard Library and fill many of the functional gaps left open by it.

Their modular and efficient design and implementation makes the C++ Portable Components extremely well suited for embedded development, an area where the C++ programming language is becoming increasingly popular, due to its suitability for both low-level (device I/O, interrupt handlers, etc.) and high-level object-oriented development. Of course, POCO is also ready for enterprise-level challenges.

The POCO libraries free developers from re-inventing the wheel, and allow them to spend their time on more worthwhile areas, such as getting things done quickly and working on the features that make their application unique.

Frodo application is a portable C64 emulator.
Frodo is a free, portable Commodore 64 emulator that focuses on the exact reproduction of special graphical effects possible on the C64.
It is capable of running most games and demos correctly, even those with FLI, FLD, DYCP, open borders, multiplexed sprites, timing dependent decoders, fast loaders etc.
Enhancements:
- An enhanced Tcl/Tk preferences GUI written by Gerard Decatrel
- The ability to use SDL for graphics output which eliminates the restriction to 8-bit screens (which probably no-one is using any more). If you have SDL version 1.2 or higher installed, the configure script will automatically detect and use it.

C++ Portable Types Library (PTypes) is a simple alternative to the STL that includes multithreading and networking. C++ Portable Types Library (PTypes) defines dynamic strings, variants, character sets, lists and other basic data types along with portable thread and synchronization objects, IP sockets and named pipes. Its main `target audience is developers of complex network daemons, robots or non-visual client/server applications of any kind.
PTypes defines simple and intuitive interfaces and differs from the STL in fairly moderate use of templates. The library is portable across many modern operating systems (currently FreeBSD, Linux, SunOS, Mac OS X and Windows). All platform-dependent issues are hidden inside. A simple web server called wshare is included in the package to demonstrate the full power of the library.
And finally, PTypes is open and free.
Main features:
- Threads and synchronization primitives solve the vital problem of diversity of the threading APIs on different platforms. The library also offers message queues and job queues as additional methods of thread synchronization and maintenance.
- IP socket classes and utilities provide complete IP-based framework for both client-side and server-side programming. Combined with PTypes multithreading, these classes can be used for designing complex non-visual applications, such like network daemons or web robots.
- Dynamic strings, variants, character sets, date/time type and various kinds of dynamic and associative arrays: Delphi programmers will find them very similar to the ones in their favorite language. The collection of these basic data types may be useful, among other things, for building compilers and interpreters for higher-level languages.
- Streaming interfaces provide buffered I/O with simple and powerful text parsing methods. A strictly defined syntax for a given text format or a formal language can be represented by calls to PTypes token extraction methods. The unified streaming interface is applicable to files, named pipes and network sockets.
- Special thread class with enhanced functionality called unit. Units have their own main() and input/output plugs; they can be connected to each other within one application to form pipes, like processes in the UNIX shell.
- Finally, everything above is portable: all platform-dependent details are hidden inside.
Enhancements:
- Added support for HP-UX
- Compilation problems solved on *BSD systems (64-bit seek issue)
- Several MacOS X compilation problems solved (socklen_t, libtool)
- MSVC project files are now in the new VC7+ format (.sln, .vcproj)
- Dropped support for BSDi, CygWin and also the Borland C++ compiler.

USB Pen Drive Linux is portable Linux compilation that is based purely on Debian Linux. The project can be installed to a portable hard drive, USB flash pen drive or even an ipod or other portable device.

USB Linux installation enables you to install a portable Linux operating system on a flash drive no larger than your thumb. This portable Linux version can then be run from any computer that can boot from a flash device.

This process allows you to bring your operating system, desktop, applications, files, e-mail, personal settings, favorites and more with you. It’s like having your own personal operating system you can carry in your pocket. On this site, we provide many simplified portable Linux flash drive tutorials.

The Configuration File Library (CFL) is a collection of routines for manipulating configuration files. The project is a portable library fully written from scratch in pure ANSI C.

It is designed to offer for C programmers common routines for manipulating configuration text files.

LucidLife is a free and usable implementation of Conways Life. Aimed at users of the GNOME desktop environment, LucidLife should also be portable to other platforms. LucidLife is based on GtkLife.