Apache Tcl is an umbrella for Tcl-Apache integration efforts. These projects combine the power of the Apache web server with the capabilities of the mature, robust and flexible Tcl scripting language.

PHP is a widely-used Open Source general-purpose scripting language that is especially suited for Web development and can be embedded into HTML. Its syntax draws upon C, Java, and Perl, and is easy to learn. PHP runs on many different platforms and can be used as a standalone executable or as a module under a variety of Web servers. It has excellent support for databases, XML, LDAP, IMAP, Java, various Internet protocols, and general data manipulation, and is extensible via its powerful API. It is actively developed and supported by a talented and energetic international team. Numerous Open Source and commercial PHP-based application packages are available.

This project aims at making a graphical development environment based on a Basic interpreter, so that we have a language like Visual Basic™ under Linux™.

Gambas is, before all, a Basic language with object extensions. A program written with Gambas is a set of files. Each file describes a class, in terms of object programming. The class files are compiled, then executed by an interpreter. From this point of view, it is very inspired by Java.

Gambas is made up of the following programs :

• A compiler.
• An interpreter.
• An archiver.
• A graphical user interface component.
• A development environment.

The development environment is written with Gambas itself, so that I can show the abilities of the language. And it is very useful for debugging !

BeanShell is a small, free, embeddable Java source interpreter with object scripting language features, written in Java. BeanShell dynamically executes standard Java syntax and extends it with common scripting conveniences such as loose types, commands, and method closures like those in Perl and JavaScript.

You can use BeanShell interactively for Java experimentation and debugging as well as to extend your applications in new ways. Scripting Java lends itself to a wide variety of applications including rapid prototyping, user scripting extension, rules engines, configuration, testing, dynamic deployment, embedded systems, and even Java education.

BeanShell is small and embeddable, so you can call BeanShell from your Java applications to execute Java code dynamically at run-time or to provide extensibility in your applications. Alternatively, you can use standalone BeanShell scripts to manipulate Java applications; working with Java objects and APIs dynamically. Since BeanShell is written in Java and runs in the same VM as your application, you can freely pass references to "live" objects into scripts and return them as results.

In short, BeanShell is dynamically interpreted Java, plus a scripting language and flexible environment all rolled into one clean package.

Jython is an implementation of the high-level, dynamic, object-oriented language Python written in 100% Pure Java, and seamlessly integrated with the Java platform. It thus allows you to run Python on any Java platform.

Python is an interpreted, interactive, object-oriented programming language. It combines remarkable power with very clear syntax, and isn't difficult to learn. It has modules, classes, exceptions, very high level data types, and dynamic typing. There are interfaces to many system calls and libraries, as well as to various windowing systems (Tk, Mac, MFC, GTK+, Qt, wxWindows). New built-in modules are easily written in C or C++. Python is also usable as an extension language for applications that need a programmable interface.

JRuby is the effort to recreate the Ruby interpreter in Java. JRuby is tightly integrated with Java to allow both to script any Java class and to embed the interpreter into any Java application.

JRuby Features

• Ruby 1.8.2 compatible interpreter.
• Most builtin classes implemented
• Support for scripting Java classes and interfaces in JRuby.
• Bean Scripting Framework (BSF) support.

R is a language and environment for statistical computing and graphics. It is a GNU project which is similar to the S language and environment which was developed at Bell Laboratories (formerly AT &T, now Lucent Technologies) by John Chambers and colleagues. R can be considered as a different implementation of S. There are some important differences, but much code written for S runs unaltered under R.

R provides a wide variety of statistical (linear and nonlinear modelling, classical statistical tests, time-series analysis, classification, clustering, ...) and graphical techniques, and is highly extensible. The S language is often the vehicle of choice for research in statistical methodology, and R provides an Open Source route to participation in that activity.

One of R's strengths is the ease with which well-designed publication-quality plots can be produced, including mathematical symbols and formulae where needed. Great care has been taken over the defaults for the minor design choices in graphics, but the user retains full control.

Scheme is a statically scoped and properly tail-recursive dialect of the Lisp programming language. It was designed to have an exceptionally clear and simple semantics and few different ways to form expressions. A wide variety of programming paradigms, including imperative, functional, and message passing styles, find convenient expression in Scheme.

Scheme is often used in computer science curricula and  programming language research, due to its ability to represent  many programming abstractions with its simple primitives. It is also an ideal test bed for compilation and interpretation  techniques since it is possible to write a simple, yet fully standards-compliant Scheme interpreter in just a few days.

Io is small prototype-based programming language. The ideas in Io are mostly inspired by Smalltalk (all values are objects), Self, NewtonScript and Act1 (prototype-based differential inheritance, actors and futures for concurrency), LISP (code is a runtime inspectable/modifiable tree) and Lua (small, embeddable).

Features

open source BSD license
pure object language
small VM (~10K lines)
small memory footprint (between 64K-200K depending on the platform)
reasonably fast (comparable to Python, Perl, Ruby)
incremental garbage collector, weak links supported
differential prototype-based object model
dynamic typing
exceptions
ANSI C implementation (except for use of inlines and a few lines of coroutine code)
embeddable multi-state (multiple independent VMs can run in the same application)
actor-based concurrency using coroutines/light weight threads
64 bit clean