Free flexible application software for linux

Guile is a library designed to help programmers create flexible applications. Using Guile in an application allows programmers to write plug-ins, or modules (there are many names, but the concept is essentially the same) and users to use them to have an application fit their needs.

There is a long list of proven applications that employ extension languages. Successful and long-lived examples in the free software world are GNU Emacs and The GIMP.

Very popular examples of extending server applications are the Apache projects Perl and PHP modules.

Extension languages allow users, programmers, and third-party developers to add features to a program without having to re-write the program as a whole, and it allows people extending a program to co-operate with each other, without having to expend any extra effort.

Guile is an interpreter for the Scheme programming language, packaged as a library which can be incorporated into your programs. Your users have full access to the interpreter, so Guile itself can be extended, based on the needs of the user. The result will be a scripting language tailored to your application.

Using Guile with your program makes it more usable. Users dont need to learn the plumbing of your application to customize it; they just need to understand Guile, and the access youve provided. They can easily trade and share features by downloading and creating scripts, instead of trading complex patches and recompiling their applications. They dont need to coordinate with you, or anyone else.

OpenThought is a Web Application Environment which doesnt require page reloads.

SYNOPSIS

use OpenThought();

my $o = OpenThought->new( $OP );

my $field_data;
$field_data->{myTextBox} = "Text Box Data";
$field_data->{myCheckbox} = "true";
$field_data->{myRadioBtn} = "RadioBtnValue";
$field_data->{mySelectList} = [
[ "text1", "value1" ],
[ "text2", "value2" ],
[ "text3", "value3" ],
];

my $html_data;
$html_data->{id_tagname} = "New HTML Code";

print $o->serialize({
fields => $field_data,
html => $html_data,
focus => "myTextBox",
javascript => $javascript_code
});

OpenThought is a powerful and flexible web application environment. OpenThought applications are different from other web applications in that all communication between the browser and the server is performed in the background. This gives a browser the ability to receive data from the server without ever reloading the currently loaded document. Data received can be displayed automatically on the existing page, can access JavaScript functions and variables, and can load new pages. Additionally, OpenThought completely manages all of your session data for you. These features give the look and feel of a full-blown application instead of just an ordinary Web page.

OpenThought is extended with OpenPlugin, also described briefly in this documentation.

OpenThought works by communicating with the server through the use of a hidden frame. Now some may say "Frames? Youre using frames??" No need to fret though, the frame is completely hidden. There is no visible way for your users to tell that they are using an application which makes use of frames.

This hidden frame performs all communication with the server for you, and allows your browser to talk to the server without reloading the content currently visible in your web browser. This is how OpenThought can update portions of the screen, and how the server can run JavaScript code in the browser, all without reloading the page.

Any time an OpenThought application is loaded, a unique session id is generated for that user. Each time communication takes place between the browser and server, OpenThought is careful to make sure that this session id is sent along with the request. There is nothing you need to do to make this work, it is done for you. When youre programming your application, you can always expect a session id to be sent to the server, and you can easily retrieve it along with the rest of the data sent by the browser.

In addition to being able to update portions of a screen, you can also load new pages within the content frame. If you choose to load new pages, your session continues to be maintained.

OpenThought gives you an easy way of tieing together multiple web pages, and allows you to build web applications which act like "real" applications. When an application is required, some people would decide to build it in Tk, Visual Basic, Gtk, or any number of other systems which offer a visual interface. But then, your application is either not available on the web, or you have to create a seperate web interface to interact with the backend.

Have you ever tried to create a web interface which minics the interface of a non-web based application? The web based application no longer looks or acts like your other interface, it acts like an ordinary webpage. It probably uses several screens to get the same amount of content that your application offered in one.

By not ever needing to reload the page, OpenThought offers this application look and feel thats been missing from the web. This allows you to create just one interface, for both LAN and web use.

FinScribe is a flexible web authoring application, which provides Wiki and Weblog authoring functionality in one application (commonly referred to as a "bliki".)
FinScribe was written as a technology demonstration for the Fins web application framework, FinScribe has grown into a full featured application that offers the best features of many different applications in one easy to use package.
FinScribe (and indeed, the whole underlying Fins framework) was born out of a desire to replace SnipSnap as the engine for this website. While it was (and is) a wonderful application, SnipSnap had a few very bad habits, such as eating a large amount of RAM and being rather slow. Additionally, SnipSnaps development pace had slowed considerably, leaving me to wonder if the shortcomings Id encountered would be fixed or improved in a timely manner.
After approximitely a week of development, FinScribe replaced SnipSnap on this website, and we havent looked back since. Weve made a large number of enhancements since then, and hope to continue the current pace of development in the future.
Note: There is no SnipSnap code in FinScribe, though the CSS stylesheets shipped with FinScribe are very slightly modified versions of those included with SnipSnap.
This is primarily due to the fact that this application was designed to be at least partially compatible with SnipSnap. As things continue to develop, well probably replace the stylesheets with something more original.
Main features:
- Flexible Wiki engine using SnipSnap compatible markup
- Weblog functionality
- Multiple Weblogs per application (each page may be a weblog)
- Multi-user capable
- Per-object Comments
- Extendible via Plugins (both wiki markup and application level macros)
- Produces RSS 2.0 feeds for Weblogs
- Includes an RSS 0.92/1.0/2.0 feed reader
- Category support
- Attachment support
- User administration
- User self-registration
- Skinnable interface using CSS
- Versioning capability (new versions are created upon object saves)
- Deployable as a standalone web server, as a module within Caudium, or using [external]FastCGI (tested with Apache).

Sendmail application is a Mail Transfer Agent, which is the program that moves mail from one machine to another.

Sendmail implements a general internetwork mail routing facility, featuring aliasing and forwarding, automatic routing to network gateways, and flexible configuration.

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!)

Prima::Application is root of widget objects hierarchy.

Prima::Application class serves as a hierarchy root for all objects with child-owner relationship. All toolkit objects, existing with non-null owner property, belong by their top-level parental relationship to Prima::Application object. There can be only one instance of Prima::Application class at a time.

SYNOPSIS

use Prima;
use Prima::Application;
or
use Prima qw(Application);

Prima::MainWindow-> create();

run Prima;

USAGE

Prima::Application class, and its only instance are treated specially throughout the toolkit. The object instance is contained in

$::application

scalar, defined in Prima.pm module. The application instance must be created whenever widget and window, or event loop functionality is desired. Usually

use Prima::Application;

code is enough, but $::application can also be assigned explicitly. The use syntax has advantage as more resistant to eventual changes in the toolkit design. It can also be used in conjunction with custom parameters hash, alike the general create() syntax:

use Prima::Application name => Test application, icon => $icon;

In addition to this functionality Prima::Application is also a wrapper to a set of system functions, not directly related to object classes. This functionality is generally explained in "API".

CGI::Application::Magic is a template based framework for CGI applications.

SYNOPSIS

package WebApp ;
use base CGI::Application::Magic ;

# optional runmethod
sub RM_myRunMmode
{
... do_something_useful ...
... no_need_to_set_page ...
... returned_value_will_be_ignored ...
}

# package where Template::Magic will looks up
package WebApp::Lookups ;

# this value will be substituted to each
# app_name label in each template that include it
our $app_name = WebApp 1.0 ;

# same for each Time label
sub Time { scalar localtime }

# and same for each ENV_table block
sub ENV_table
{
my ($self, # $self is your WebApp object
$zone) = @_ ; # $zone is the Template::Magic::Zone object
my @table ;
while (my @line = each %ENV)
{
push @table, @line
}
@table ;
}