Free flexible application software for linux

Just Another Web mail is a flexible, powerful and fast webmail written in PHP.
Technically, JAWmails core is JAW - a flexible framework for web application development; JAWmail its packed with some applications and a simple, web based installer.
Main features:
- Connects to IMAP servers using PHPs IMAP extension
- Has support for multitiple drivers for backend authentication, session managment, access control lists, ...
- Support for multitiple language
- Uses UTF-8 as the internal charset; automatically converts messages in different charsets
- Renders XHTML 1.0
- Themable (you can replace CSS styles and images)
- Help system with XML backend
- Object oriented design
- Address book with support for different backend drivers
- Plugin system
- Powerful message highlighting
- A lot of preferences
- Importing and exporting of messages via UNIX mbox files
- ...and more!

PHPortal is a PHP application development environment similar to Zope. It is a pipeline or tunnel application that can help you quickly create dynamic Web applications such as portal and intranet sites. It comes with membership, search, news, and more.

Its easy-to-use tools allow teams to productively and safely work together. It provides access to databases and other legacy data. Its support for Web standards such as SMTP, POP, FTP, and XML-RPC allows you flexibility and interoperability.

It consists of a number of components which work together to provide a complete, yet flexible, application server package. It includes an XML-RPC server, an object-oriented database schema, a search engine, a database virtual file mapping system, a Web page templating system, a Web-based development and management tool, and comprehensive extension support.

ghli is GPMIs Highlevel Language Interpreter, developed to operate under GPMI, though it works as a standalone script interpreter as well.

It features a byte code interpreter with complex instructions for high level languages, a framework to ease implementing precompilers, a Pascal precompiler, and an Assembly precompiler.

It aims to be small, fast, and flexible. The number of core instructions are very limited while it offers a simple interface so the host application can register its own extension commands easily.

Ignorance is a content filtering plugin for Gaim. If you love Gaim for chat, but find yourself missing the filtering features of clients like zinc, then Ignorance is for you!

DNA (Deep Network Analyser) is an open, flexible, and extensible deep network analyzer server and software architecture for passively gathering and analyzing network packets, network sessions, and applications protocols.
Deep Network Analyser project is designed to be used for Internet security, network management, intrustion detection, protocol and network analysis, information gathering, and network monitoring applications.
Main features:
- Extensible Java based network sensor (processing layers 2-7)
Configurable processing and output:
- Packet flows like Ethereal
- IP Flows like CISCO netflow
- Stateful Sessions (client/server flow pairs)
- Application protocol element output
- Configurable and extensible application protocol element parsing.
- Application protocol parsing toolkit APIs allows for new protocol parser to be easily developed and extended
- Targeting based full session capture facility, like a realtime targeted TCPDump.
- Flexible targeting from IPAddr, Port tuple to Application sensitive targeting.
- Configurable and extensible output forwarding (file, DB, Streams, JMS, RMI, etc.)
- Extensible realtime collection portable to many OS/Packet processing environments
Easily adaptable to packet processing environments:
- Specialized linux drivers mechanismon
- Network Appliances
- Network Switches / Routers
- Highly mutithreaded for increased performance over multi processor environments
Enhancements:
- Adoption of OpenAdaptor(tm) as the Output Adapter mechanism.
- Support for local-only administration.
- A new targeted packet capture parser, new run scripts, and a new install mechanism.
- Many bugfixes.

php.MVC implements the Model-View-Controller design pattern, and encourages application design based on the Model 2 paradigm. This design model allows the Web page or other contents (View) to be mostly separated from the internal application code (Controller/Model), making it easier for designers and programmers to focus on their respective areas of expertise.
The framework provides a single entry point Controller. The Controller is responsible for allocating HTTP requests to the appropriate Action handler (Model) based on configuration mappings.
The Model contains the business logic for the application. The Controller then forwards the request to the appropriate View component, which is usually implemented using a combination of HTML with PHP tags in the form of templates. The resulting contents are returned to the client browser, or via another protocol such as SMTP.
php.MVC is a PHP port of Jakarta Struts. It currently supports many features of Struts, including declarative application configuration via the XML digester. For example, mappings from the various Action business logic components to appropriate results pages can be specified declaratively in the XML configuration file.
Main features:
- Free OpenSource software: This gives users full control of the software, and the able to modify the source code to suit specific needs.
- Security: php.MVC applications have only one entry point (per application). This makes it easy to protect sensitive application code and data.
- Flexible Installation: Individual php.MVC applications can be installed outside of the main php.MVC library directory tree.
- Multi-applications: There is no limit to the number of applications per php.MVC installation.
- Object Oriented design (OOD). The php.MVC framework is based on OOD principles, making it more extendable and maintainable.
- Database integration: The php.MVC framework ships with the Pear::DB Database Abstraction Layer, and a driver for the MySQL relational database manager (RDBM) is provided.
- Action Chaining: php.MVC allows for passing control to other Actions. This makes it easy to process a sequence of Actions (business logic classes) and static resources (pages).
- XML configuration: php.MVC uses declarative application configurations using Extensible Markup Language (XML) files. Each application has its own XML configuration file.
- MVC Model 2 design: php.MVC implements the Model-View-Controller (MVC) Model 2 design pattern. The Model 2 paradigm allows the separation of the application presentation from the business logic, making it easier for designers and programmers to focus on their respective areas of expertise.
- Form button mapping: php.MVC implements the LookupDispatchAction class to enable HTML form buttons to be mapped to particular business logic methods. For example, a form submit button called "Add to Cart" could be mapped to an Action class method called MyCartAction->addToCart(...).
- Message Resources: php.MVC provides a PropertyMessageResources class that handles messages in text string properties files with parametric replacement. This can provide Locale-sensitive messages for internationalized applications.
- The php.MVC framework is based on Jakarta Struts application framework design. Struts has proven to be reliable, extendable and well supported.
Enhancements:
- This development release adds bugfixes and enhancements to the framework, a compressed performance version for use in more demanding hosting environments, and an example application to demonstrate the use of both versions.

Keystone is a cross-platform, object oriented application framework which allows applications to be written to build on the target platforms of GNU/Linux and Win32 without modification of their source.
Keystone Application Framework implements several modern Web standards, including SVG graphics and the XUL user interface description language.
Enhancements:
- A significant development in this release is the optional use of the GDI+ (Win32) and CairoGraphics (Linux) rendering backends to render SVG content.
- In addition, support for SVG paths has been much improved with the ability to render bezier and elliptical segments.

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.