Free strong smelling urine software for linux

Flexible Isometric Fallout-like Engine is a next-generation 2D engine that aims to be modern and have strong modding support. Fallout 2 graphic assets are supported.
Main features:
- is open source (GPL v2.0)
- can utilize the graphics from the original FallOut game (not distributed with FIFE!)
- supports different platforms: Linux (compiles and runs), Windows (compiles and runs) and MacOsX (compiles, cant be tested as a working .dat tool for Macintosh is missing)
- supports multiple resolutions (640x480 -> 1600x1200)
- supports fullscreen and windowed mode
- supports 16 & 32-bit colour depth
- supports OpenGL and software rendering (OpenGL is currently much faster)
- supports different alphablending modes: none, automatic, full
- is going to support weather effects (currently discussed!)
- is going to have a dynamic light system (currently discussed!)

Self-certifying File System provides a secure, global network file system with decentralized control.

SFS is a secure, global network file system with completely decentralized control. SFS lets you access your files from anywhere and share them with anyone, anywhere.

Anyone can set up an SFS server, and any user can access any server from any client.

At the same time, SFS uses strong cryptography to provide security over untrusted networks.

Thus, you can safely share files across administrative realms without involving administrators or certification authorities.

Starfish Password Manager project consists of a password manager.
Starfish is a simple password manager. It stores all of its data in XML, and uses strong encryption (MD5 with DES).
Main features:
- 100% Java©
- Easy to use GUI
- Strong encryption
- Sortable columns, password hiding/unhiding
- Easy copy to clipboard
- All data stored in XML

Felix is an advanced Algol like procedural programming language with a strong functional subsystem. It features ML style typing, first class functions, pattern matching, garabge collection, polymorphism, and has built in support for high performance microthreading, regular expressions and context free parsing.

The system provides a scripting harness so the language can be used like other scripting languages, but underneath it generates native code to obtain high performance.

A key feature of the system is that it uses the C++ object model, and provides an advanced binding sublanguage to support integration with C++ at both the source and object levels, both for embedding C++ data types and functions into Felix, and for embedding Felix into exitsing C++ architectures.

The Felix compiler is written in Objective Caml, and generates ISO C++ which should compile on any platform.

Nowadays computers and internet are part of our everyday life: work, school, home. Nevertheless we have our private sphere and we are guarding it with restricted areas accessible with passwords. The better the password, the secure your information is. Therefore we need tools to test and to create better, nontrivial passwords.
- the analyser (shows the "strength" of your pass phrase regarding some rules) and the generator (generates a "strong" pass phrase regarding some rules).
More specific information (rules for creating secure passwords, how to use the tool etc.) can be found by following the above links.
Enhancements:
- A MIDLET version for Java-capable mobile devices is now also available.

HTML::Sanitizer is a HTML Sanitizer.

SYNOPSIS

my $safe = new HTML::Sanitizer;

$safe->permit_only(
qw/ strong em /,
a => {
href => qr/^(?:http|ftp):/,
title => 1,
},
img => {
src => qr/^(?:http|ftp):/,
alt => 1,
},
b => HTML::Element->new(strong),
);

$sanitized = $safe->filter_html_fragment($evil_html);

# or

my $tree = HTML::TreeBuilder->new->parse_file($filename);
$safe->sanitize_tree($tree);

ABSTRACT

This module acts as a filter for HTML. It is not a validator, though it might be possible to write a validator-like tool with it. Its intended to strip out unwanted HTML elements and attributes and leave you with non-dangerous HTML code that you should be able to trust.

con:cern project is a workflow engine based on an extended case handling approach.
A process is described as a set of activities with pre- and postconditions. An activity is executed when its preconditions are met. It manipulates the process item, thereby creating postconditions. The process flow is determined at runtime. This approach is superior to the conventional process flow approach, especially if high flexibility and modularity are required.
Main features:
- complex process with exceptions and special cases
- execution sequence is dependent on multiple factors
- possibility of manual intervention of process flow
- content-based dependence amongst activities
- strong requirements to modularity
- strong requirements to flexibility
- loose process coupling
Interestingly, processes often turn out to be more complex than initially anticipated. con:cerns flexibility allows to restrict yourself to implementing the normal process flow. Special cases and exceptions can be manually dealt with at run-time, or can be gradually retrofitted.
When you can break systems down to pre conditions, post conditions, transfer functions, and the algorithms that implement them you can go a long way towards reliable systems and specs.
Enhancements:
- bugfix escalation timeout
- bugfix reenlistment after escalation