Free adults software for linux

Web-Based Adult Content Server is a suite of programs which manage photo sets and video clips of an adult nature.
It runs on a home Linux/Unix server and creates a personalized adult Web server in which to store, preuse, and catalogue a personal collection of adult material.
Web-Based Adult Content Server has many features, like model catalogs, attribute-based searching, randomized highlights, new addition lists, and a flexible bookmark mechanism.
Enhancements:
- This release has new features and many bugfixes.
- It includes a new Web-based Model Manager application, locations-based filtering (e.g. Bathroom), and a new connections infrastructure for galleries and ad-hoc collections.

Planets is a simple interactive program for playing with simulations of planetary systems, released under the GPL. The project runs on Linux and Windows, and could doubtless be ported to your favorite flavor of Unix.
Planets was originally designed for kids, in particular, for my then 4-year old nephew who is fascinated by astronomy. The user interface is aimed at being simple enough that a fairly young kid can get some joy out of it. But the adults who have used it have found it to be pretty fun as well.
The code is not bug-free, and Planets is missing some significant features. But its pretty stable and is a fun toy to play with. If you do download it, please drop me an email and tell me about your experience with it.
Main features:
- Saving and loading of universes
- Infinite undo (erase last action) and goback (return to point in time just after last action). This allows for undoing mistakes and replaying interesting configurations.
- Traces of planet trajectories
- Two ways of dealing with planet collisions:
- merges, where the colliding planets are merged into one planet, and
- bounces, where the colliding planets are bounced off each other elastically. This itself comes in two varieties:
- force bouncing, where the force between planets is made repulsive at close quarters.
- true bouncing, where simple pool-table physics calculations are made to determine when planets collide, and compute the appropriate bounce from said collision.
- kidmode, a mode where the focus is (mostly) locked on the application, and interesting changes are initiated by merely banging on the keyboard. This mode is aimed at 1-5 year olds.
- Center-of-mass following: it is possible to follow the center of mass of a subset of the planets. Thus, if you have a sun-moon-planet system, you can have the view automatically track the moon-planet pair.
- Can display kinetic, potential and total energy of the system.
- Both the gravitational constant and the gravitational exponent can be changed.
- There is a simple control panel that makes it possible to see and change the simulation options.
- Zooming, panning, and centering on the center of mass.

Wallpapoz tool enables your Gnome desktop to have different wallpapers for different workspaces or virtual desktops. It offers quick orientation cues where you are. The other reason is to increase eye candy. In this version, it support randomization.

It means you can group your wallpapers into spesific workspaces. You can manage it so that your cartoon wallpapers will be randomize for certain times in workspace one, your nature wallpapers in workspace two, your adult wallpapers in workspace three and your Gnome wallpapers in workspace four.

There are two programs. One is the daemon that will monitor your desktop continuously. So when you change workspace or specified time has passed, the daemon wil change your desktop wallpaper.

The daemon it self reads your wallpapers list and preferation then acts according to that. The configuration file is written in xml format. Of course you can edit with any text editor but that is not convenient.

To make it easy, there is another program to edit this configuration file. Click the button, find the wallpapers that you would like to put into spesific workspace. Please see the screenshot to see how it works.

The daemon program name is daemon_wallpapoz.py. You need to add this program into Gnome start up programs list if you want every time you log into Gnome session, your Gnome desktop will have the ability to have different wallpapers for different workspaces. But first you need to make the configuration file by using program that called wallpapoz.py.

AI::Fuzzy is a Perl extension for Fuzzy Logic.

SYNOPSIS

use AI::Fuzzy;

my $f = new AI::Fuzzy::Label;

$f->addlabel("baby", -1, 1, 2.5);
$f->addlabel("toddler", 1, 1.5, 3.5);
$f->addlabel("little kid", 2, 7, 12);
$f->addlabel("kid", 6, 10, 14);
$f->addlabel("teenager", 12, 16, 20);
$f->addlabel("young adult", 18, 27, 35);
$f->addlabel("adult", 25, 50, 75);
$f->addlabel("senior", 60, 80, 110);
$f->addlabel("relic", 100, 150, 200);


for (my $x = 0; $xlabel($x) . "n";
}

gbrainy is a brain teaser game and trainer to have fun and to keep your brain trained.

The application is written for GNOME using Mono, C# and Cairo.

gbrainy mission is to provide a platform for creating different kinds of brain-teasers and brain trainers games for GNOME.

Use cases:

Currently the following use cases are considered:

New user.A person that uses gbrainy to evaluate it and understand what can provide. Interested in see its different kinds of games in a short period of time.

Adult gamer.An adult that uses gbrainy just for fun.

Adult training.An adult that uses gbrainy to train her memory, arithmetical and logical capabilities.

Kid training.Her parents decided that she should use gbrainy to train her memory, arithmetical and logical capabilities.

The objective is to provide enough flexibility in terms of number of games and difficulty parametrization to make gbrainy use on these cases straight forward.

Geo::Distance is a Perl module that can calculate distances and closest locations.

SYNOPSIS

use Geo::Distance;
my $geo = new Geo::Distance;
$geo->formula(hsin);
$geo->reg_unit( toad_hop, 200120 );
$geo->reg_unit( frog_hop => 6 => toad_hop );
my $distance = $geo->distance( unit_type, $lon1,$lat1 => $lon2,$lat2 );
my $locations = $geo->closest(
dbh => $dbh,
table => $table,
lon => $lon,
lat => $lat,
unit => $unit_type,
distance => $dist_in_unit
);

This perl library aims to provide as many tools to make it as simple as possible to calculate distances between geographic points, and anything that can be derived from that. Currently there is support for finding the closest locations within a specified distance, to find the closest number of points to a specified point, and to do basic point-to-point distance calculations.

METHODS

new

my $geo = new Geo::Distance;
my $geo = new Geo::Distance( no_units=>1 );

Returns a blessed Geo::Distance object. The new constructor accepts one optional argument.

no_units - Whether or not to load the default units. Defaults to 0 (false).
kilometer, kilometre, meter, metre, centimeter, centimetre, millimeter,
millimetre, yard, foot, inch, light second, mile, nautical mile,
poppy seed, barleycorn, rod, pole, perch, chain, furlong, league,
fathom

formula

if($geo->formula eq hsin){ ... }
$geo->formula(cos);

Allows you to retrieve and set the formula that is currently being used to calculate distances. The availabel formulas are hsin, polar, cos, and mt. hsin is the default and mt/cos are depreciated in favor of hsin. polar should be used when calculating coordinates near the poles.

reg_unit
$geo->reg_unit( $radius, $key );
$geo->reg_unit( $key1 => $key2 );
$geo->reg_unit( $count1, $key1 => $key2 );
$geo->reg_unit( $key1 => $count2, $key2 );
$geo->reg_unit( $count1, $key1 => $count2, $key2 );

This method is used to create custom unit types. There are several ways of calling it, depending on if you are defining the unit from scratch, or if you are basing it off of an existing unit (such as saying 12 inches = 1 foot ). When defining a unit from scratch you pass the name and rho (radius of the earth in that unit) value.

So, if you wanted to do your calculations in human adult steps you would have to have an average human adult walk from the crust of the earth to the core (ignore the fact that this is impossible). So, assuming we did this and we came up with 43,200 steps, youd do something like the following.

# Define adult step unit.
$geo->reg_unit( 43200, adult step );
# This can be read as "It takes 43,200 adult_steps to walk the radius of the earth".

Now, if you also wanted to do distances in baby steps you might think "well, now I gotta get a baby to walk to the center of the earth". But, you dont have to! If you do some research youll find (no research was actually conducted) that there are, on average, 4.7 baby steps in each adult step.

# Define baby step unit.
$geo->reg_unit( 4.7, baby step => adult step );
# This can be read as "4.7 baby steps is the same as one adult step".

And if we were doing this in reverse and already had the baby step unit but not the adult step, you would still use the exact same syntax as above.
distance

my $distance = $geo->distance( unit_type, $lon1,$lat1 => $lon2,$lat2 );

Calculates the distance between two lon/lat points.
closest

my $locations = $geo->closest(
dbh => $dbh,
table => $table,
lon => $lon,
lat => $lat,
unit => $unit_type,
distance => $dist_in_unit
);

This method finds the closest locations within a certain distance and returns an array reference with a hash for each location matched.

The closest method requires the following arguments:

dbh - a DBI database handle
table - a table within dbh that contains the locations to search
lon - the longitude of the center point
lat - the latitude of the center point
unit - the unit of measurement to use, such as "meter"
distance - the distance, in units, from the center point to find locations

The following arguments are optional:

lon_field - the name of the field in the table that contains the longitude, defaults to "lon"
lat_field - the name of the field in the table that contains the latitude, defaults to "lat"
fields - an array reference of extra field names that you would like returned with each location
where - additional rules for the where clause of the sql
bind - an array reference of bind variables to go with the placeholders in where
sort - whether to sort the locations by their distance, making the closest location the first returned
count - return at most these number of locations (implies sort => 1)

This method uses some very simplistic calculations to SQL select out of the dbh. This means that the SQL should work fine on almost any database (only tested on MySQL and SQLite so far) and this also means that it is fast. Once this sub set of locations has been retrieved then more precise calculations are made to narrow down the result set. Remember, though, that the farther out your distance is, and the more locations in the table, the slower your searches will be.

WWW::Yahoo::Groups::Mechanize is a Perl module to control WWW::Mechanize for WYG.

This module is a subclass of WWW::Mechanize that permits us a bit more control over some aspects of the fetching behaviour.

INHERITANCE

This module inherits from WWW::Mechanize, which inherits from LWP::UserAgent. As such, any method available to either of them is available here. Any overridden methods will be explained below.

CONSTRUCTOR

new

As for "new()" in WWW::Mechanize but sets the agent string to our custom agent.

METHODS

debug

Sets or gets whether we are in debugging mode. Returns true if set, else false.

warn "Awooga!" if $self->debug;
$self->debug( 1 );

get

We override get in order to provide some behind the scenes actions.

Sleeping

We allow you to rate limit your downloading. See "autosleep".

Automatic adult confirmation

We automatically click Accept on adult confirmation. So I hope you agree to all that.

Debugging

If debug is enabled, then it will display a warning showing the URL.

I should probably shift the advertisement interruption skipping into this method at some point, along with the redirect handling.

It will throw a X::WWW::Yahoo::Groups::BadFetch if it is unable to retrieve the specified page.

Returns 0 if success, else an exception object.

my $rv = $y->get( http://groups.yahoo.com );
$rv->rethrow if $rv;

# or, more idiomatically
$rv = $y->get( http://groups.yahoo.com ) and $rv->rethrow;

autosleep

Allows one to configure the sleep period between fetches The default is 1 (as of 1.86).

my $period = $ua->autosleep;
$ua->autosleep( 10 ); # for a 10 second delay

Friend & Love project is a dating system script. Its features include profiles, adult profiles, sending of kisses, notes, emails, and winks, viewing of tracks, a display of whos online and whos new, and profile searches.
What the script will do for you
- Checks server requirement.
- Checks all files, directories are original, current version and present on your sever after upload.
- Checks if any file or directory has been corrupted during the upload.
- Checks files and directories permission.
- Setup database.
- Setup the simple configuration file for you.
What the script will not do
- Not help you to upgrade from previous version (Ubolratana1.1.5SP). This one supports only fresh install. We recommend you to not use this script for live website during beta version.
- Not help you for full configuration. You have to download config.php to change some variables by yourself.
Enhancements:
- This release removes the md5 hash check and enhances the installer.
- It includes newsletter registration.
- Some unused images have been removed.
- Minor bugs in several files have been fixed.