Free in pure software for linux

XIRE (eXtendable Information Rendering Engine) is an extendable DOM-based PHP 5 template engine that takes data provided by PHP and creates XML (or XHTML) documents based on templates.
XIRE is designed to work within other projects and is not anything but a templating engine. It is not a framework and does not provide duplicate routines that may exist elsewhere in your projects. Routines such as error handling (XIRE will throw exceptions), resource fetching, and debuging are assumed to exist elsewhere.
Main features:
- Pure PHP 5 OOP - XIRE is implemented in pure PHP 5 using DOM
- Plugins - XIRE is specifically designed to be extended, if needed, to suit any application
- DOM - Which means that plugin developers have exquisite control for template processing
- XML Templates - There is no PHP in the templates and XIRE Templates are just XML so there is no need to learn any new syntax
- Safe - Again, no PHP also means non-programmer template designers can not accidently (or intentionally) compromise a system
- Simple to use - A template is not more complicated than an XML document.
- WYSIWYG safe - Templates can can be safely loaded into dreamweaver (this is just a guess, not yet tested)
How it works:
XIRE templates are merely XML documents that are processed by XIRE plugins. A plugin handles the processing of all nodes with the XIRE namespace (a node can be an element, ie. a tag, or attribute in your template) that it is registered to (based on the nodes local name).
For instance, when a plugin is registered to "zechs" then whenever a XIRE process encounters an element or attribute called "zechs" the plugin is called to handle it. If a plugin is not registered to the node, then XIRE will search in all registered directories for a plugin with the nodes name and register it. The process leaves the plugin to handle the node (and all of its child nodes) and continues the breadth-first search for other nodes to be processed.

Myintcl is an interface for using MySQL in Tcl programs, and it is written only in pure Tcl. The API design of Myintcl library follows that of fbsql.

Dyne:bolic GNU/Linux is a live bootable distribution, an operating system which can also be installed just by copying a directory onto the hard disk.
Dyne:bolic GNU/Linux is user-friendly, recognizes your hardware devices (sound, video, firewire, and USB), and offers a vast range of software for multimedia production: editing and streaming of audio and video, 3D modeling, photos, peer-to-peer filesharing, Web browsing and publishing, word processing, email, encryption, and networking.
Enhancements:
- The pure:dyne low latency GNU/Linux distribution for media artists comes with optimized and tested software such as supercollider, icecast, csound, packet forth, fluxus, and much more, including pure data and a collection of essential externals and abstractions (PDP, PiDiP, Gem, GridFlow, RRadical, and PixelTango).
- It is compatible with dyne:II, so all the Home Studio "classics" can be used (Ardour, LADSPA, seq24, Rezound etc.).
- Numerous essential graphics programs are also bundled (such as Inkscape, GIMP, and Blender).

Pure FTP Manager allows a user to access multiple FTP chrooted sites with a single username and password. The program uses pure-ftpd and PostgreSQL for FTP and authentication. A site is chosen by adding @sitename to the users login

The Pure Perl RayCaster is a small simple Ray casting application written completely in Perl without using any 3D API library or OpenGL. For the GUI, Pure Perl RayCaster uses wxPerl (WxWindows port to Perl).

Pure Perl RayCaster can load a 3D object from a file (in RAW format), display the object in wireframe perspective view, allow to orbit and zoom your camera and produce a user defined size ray casting image of the current view in a predefined color theme with or without smooth shading.

Pure Perl RayCaster is not a professional production tool for 3D image generation. It is well suited for educational purposes, in order to study, understand, tweak and try well known fundamental 3D Computer Graphics techniques.

Class::Multimethods::Pure is a Perl module that contains a method-ordered multimethod dispatch.

SYNOPSIS

use Class::Multimethods::Pure;

package A;
sub magic { rand() > 0.5 }
package B;
use base A;
package C;
use base A;

BEGIN {
multi foo => (A, A) => sub {
"Generic catch-all";
};

multi foo => (A, B) => sub {
"More specific";
};

multi foo => (subtype(A, sub { $_[0]->magic }), A) => sub {
"This gets called half the time instead of catch-all";
};

multi foo => (any(B, C), A) => sub {
"Accepts B or C as the first argument, but not A"
};
}

pybonjour provides a pure Python interface (via ctypes) to Apple Bonjour and compatible DNS-SD libraries (such as Avahi).

The application allows Python scripts to take advantage of Zero Configuration Networking (Zeroconf) to register, discover, and resolve services on both local and wide-area networks.

Since pybonjour is implemented in pure Python, scripts that use it can easily be ported to Mac OS X, Windows, Linux, and other systems that run Bonjour.

Examples

The following scripts are included in the examples directory of the pybonjour source distribution.

Registering a Service

register.py Script
import select
import sys
import pybonjour


name = sys.argv[1]
regtype = sys.argv[2]
port = int(sys.argv[3])


def register_callback(sdRef, flags, errorCode, name, regtype, domain):

if errorCode == pybonjour.kDNSServiceErr_NoError:
print Registered service:
print name =, name
print regtype =, regtype
print domain =, domain


sdRef = pybonjour.DNSServiceRegister(name = name,
regtype = regtype,
port = port,
callBack = register_callback)

try:
try:
while True:
ready = select.select([sdRef], [], [])
if sdRef in ready[0]:
pybonjour.DNSServiceProcessResult(sdRef)
except KeyboardInterrupt:
pass
finally:
sdRef.close()

Example Output

$ python register.py TestService _test._tcp 1234

Registered service:

name = TestService
regtype = _test._tcp.
domain = local.

Browsing for and Resolving Services

browse_and_resolve.py Script
import select
import sys
import pybonjour

regtype = sys.argv[1]
timeout = 5
resolved = []

def resolve_callback(sdRef, flags, interfaceIndex, errorCode, fullname,
hosttarget, port, txtRecord):
if errorCode == pybonjour.kDNSServiceErr_NoError:
print Resolved service:
print fullname =, fullname
print hosttarget =, hosttarget
print port =, port
resolved.append(True)

def browse_callback(sdRef, flags, interfaceIndex, errorCode, serviceName,
regtype, replyDomain):
if errorCode != pybonjour.kDNSServiceErr_NoError:
return

if not (flags & pybonjour.kDNSServiceFlagsAdd):
print Service removed
return

print Service added; resolving

resolve_sdRef = pybonjour.DNSServiceResolve(0,
interfaceIndex,
serviceName,
regtype,
replyDomain,
resolve_callback)

try:
while not resolved:
ready = select.select([resolve_sdRef], [], [], timeout)
if resolve_sdRef not in ready[0]:
print Resolve timed out
break
pybonjour.DNSServiceProcessResult(resolve_sdRef)
else:
resolved.pop()
finally:
resolve_sdRef.close()


browse_sdRef = pybonjour.DNSServiceBrowse(regtype = regtype,
callBack = browse_callback)

try:
try:
while True:
ready = select.select([browse_sdRef], [], [])
if browse_sdRef in ready[0]:
pybonjour.DNSServiceProcessResult(browse_sdRef)
except KeyboardInterrupt:
pass
finally:
browse_sdRef.close()

Example Output

$ python browse_and_resolve.py _test._tcp
Service added; resolving
Resolved service:
fullname = TestService._test._tcp.local.
hosttarget = bumble.local.
port = 1234
...