Free for unix shell software for linux

MirBSD Korn Shell (mksh) is an actively developed successor of pdksh (the Public Domain Korn Shell), aimed at producing a shell good for interactive use, but with primary focus on scripting.
The project is intended to be portable to most *nix-like operating systems as long as theyre not too obscure. mksh incorporates improvements from OpenBSD and Debian, as well as bugfixes and enhancements developed for the MirOS and FreeWRT projects. The emacs command line editing mode is UTF-8 capable.
The shell supports large files, as well as all pdksh and some csh, AT&T ksh, and GNU bash features, is compatible with the Bourne shell (within limits, but you can turn off brace expansion), has no limit on array sizes, and incorporates some other useful builtins and features. While being already fast and small (without losing functionality), flags to make it even smaller can be given at compile time. An interactive shell reads "~/.mkshrc" on startup.
Enhancements:
- Packagers should read the information at http://www.mirbsd.org/mksh.htm#upgrade.
- mksh can now be built on more platforms, such as AIX, and with a lot of vendor compilers (Intel, Sun, IBM, Microsoft, Borland, Digital Mars, HP) in addition to gcc.
- Some constructs from GNU bash are supported.
- The code and build system got cleaned up, fixed, and improved further.
- Large file support on some OSes and POSIX compatibility got better.

Squirrel Shell is made as a cross-platform alternative to system shells like bash in *nix.
Main features:
- object-oriented programming;
- C++-like syntax;
- dynamic typing;
- delegation;
- generators;
- exception handling;
- weak references;
Enhancements:
- Added: fprintl() function.
- Added: regcompile(), regmatch(), regfree(), regfreeall() and regerror() functions.
- Fixed: Passing null as redirIn parameter for run() function.
- Fixed: readdir() function truncated path at the first slash.
- Fixed: Floating point numbers staring with integer part equal to zero (for example, 0.123) were treated as octal integers.
- Fixed: Documentation for printl() function.
- Fixed: Potential buffer overflow in scan() and fscan() functions.
- Fixed: substr() returned one redundant character.
- Changed: Leading and trailing spaces in paths are removed.
- Changed: SQUIRREL_VERSION is now "2.1.3.1".
- Changed: Increased internal buffer for scan() and fscan() functions.
- Changed: Removed .dummy files and source code from Windows installer.

Fry::Shell is a flexible shell framework which encourages using loadable libraries of functions.
SYNOPSIS
From the commandline: perl -MFry::Shell -eshell
OR
In a script:
package MyShell;
use Fry::Shell;
#subs
sub evalIt {
my $cls = shift;
my $code = ($cls->Flag(strict)) ? use strict; : ;
$code .= "@_";
eval "$code";
}
sub listStations {
my $cls = shift;
my @stations = ( {name=>high energy trance/techno,ip=>http://64.236.34.196:80/stream/1003},
{name=>macondo salsa,ip=>http://165.132.105.108:8000},
{name=>new age,ip=>http://64.236.34.67:80/stream/2004},
);
$cls->saveArray(map{$_->{ip}} @stations);
return map {$_->{name}} @stations;
}
#set shell prompt
my $prompt = "Clever prompt: ";
#initialize shell and load a command and an option
my $sh = Fry::Shell->new(prompt=>$prompt,
load_obj=>{ cmds=>{listStations=>{a=>lS}},
opts=>{strict=>{type=>flag,a=>n,default=>0}} }
);
#begin shell loop
$sh->shell(@ARGV);
####end of example, start of other possible methods
#run shell once
$sh->once(@ARGV);
#loads libraries and runs each librarys &_initLib
$sh->initLibs(@modules);
$sh->loadFile($file);
$sh->loadPlugins($myplugin);
$sh->runCmd($cmd);
Fry::Shell is a simple and flexible way to create a shell. Unlike most other light-weight shells, this module facilitates (un)loading libraries of functions and thus encourages creating shells tailored to several modules. Although the shell is currently only viewable at the commandline, the framework is flexible enough to support other views (especially a web one. This module is mainly serving(will serve) as the model in an MVC framework.
From a user perspective it helps to know that a shell session consists of mainly four shell components (whose classes are known as core classes) : libraries (lib), commands (cmd), options (opt) and variables(var). Commands and options are the same as in any shell environment: a command mapping to a function and an option changing the behavior of a command ie changing variables within it or calling functions before the command. Variables store all the configurable data, including data relating to these commands and options. Libraries are containers for a related group of these components.
Main features:
- Loading/unloading shell components at runtime.
- Flexible framework for using shell features via plugins. You can even set up a bare minimum shell needing no external modules! Currently plugins exist for dumping data,readline support,reading shell configurations and viewing shell output.
- Commands and options can be aliased for minimal typing at the commandline.
- Commands can have help and usage defined.
- Commands can have user-defined argument types. One defines argument types by subroutines or tests that they should pass. These tests are then applied to a commands defined argument(s). With defined argument types, one can also define autocompletion routines for a commands arguments.
- Options can modify variables. Since variables exist for almost every aspect of the shell, options can change many core shell functions. A handy example is parsecmd which names the current parse subroutine for the current line. Changing this var would change how the input after the options is parsed.
- Options can have different behaviors defined including the ability to invoke subroutines when called or to maintain a value for a specified amount of iterations.
- Default options include menu which numbers output and allows the next command to reference them by number.
- Page output with preferred pager.
- Multiline mode.
- Comes with a decent default library,Fry::Lib::Default, to dump,list or unload any shell component, run system commands,evaluate perl statements and execute methods of autoloaded libraries.

xen-shell is a simple console application which allows you to easily allow the owner of a single Xen instance to control it, without the overhead of a web-based control panel.
Using this shell users may:
- Boot/Shutodwn their Xen guest.
- Reboot their Xen guest.
- Connect to the serial console of their runing Xen guest.
- Reimage their system to a pristine state, via xen-tools.
- Manipulate their reverse DNS information
The shell features command history, command completion, and integrated help.
It is ideal for a hosting company who wishes to over "virtual machine" hosting to their customers, and allow them to control their own instance.

CGI-Shell provides a shell using CGI, so everyone who has a CGI directory on a Web server can also have a shell on it. It is something like telnet or SSH.
How to install?
make
make install (you have to be root)
How to uninstall?
make uninstall (you have to be root)
The server is distributed as binary - you can also compile it yourself with "make server", but its not recommendable.
Enhancements:
- PHP support (works not if system() call is disabled in PHP)
- configuration file
- bugfixes, little improvements