This page is going to be moved to another address. I will try to take care as much as possible to ensure automatic redirection then, but cannot garantee that. The stable URL for this is http://www.robert-tolksdorf.de/vmlanguages. Please correct your bookmarks.
Attention users of the Open Directory Project: The dmoz site lists the wrong URL for this page.
Programming Languages for the Java Virtual Machine
The following is a list of
programming languages for the Java virtual machine aside of Java
itself. Currently (spring 2004), it comprises about 189 different
systems. It is a mix of experimental, research oriented
implementations and of commercial ones. I excluded extensions to
Java by the provision of class libraries implementing the
functionality of other languages constructs. The source code of a
program executed in the Java VM has to have a syntax different to
Java to be included in this list.
This list is manually compiled from
the net. Most of the descriptions are slighlty editied parts of the
documentation supplied at the respective sites. If you have
comments and corrections, or want something included in the list,
please send a mail.
Instead of doing so, you might also read and extend the remarks
page on programming languages for the Java VM.
I do not take any guarantee about
the quality of software referenced here. Use at your own risk.
If you are interested in the
original Java language only, you might check out a page on Alternative Java
Implementations which provides a list of implementations of
Java Virtual Machines (JVMs), Java library implementations, Java
compilers to byte code, and compilers of bytecode or Java source to
machine code.
New entries in the list are flagged
with the
icon. As proposed by Adam Kelly, links that currently point to nowhere
now carry a icon. This means, that I would be very much interested to get
information on the new locations of these languages.
And ... it's about time to say a big thanks to all those
people that pointed me to new systems to include here. It is
amazing that not only the authors themselves help to keep this list
as complete as possible, but also people that come across something
interesting. I appreciate this very much.
Jatha macros are Java programs that write Java programs. Jatha is
a preprocessor that runs arbitrary java code in order to generate the
source code that the compiler sees. This one is different from the other Jatha listed here.
The Java Syntactic Extender is an extension to the Java language
that allows Java programmers to define new syntactic constructs. The
design is based on the Dylan macro system (e.g., rule-based pattern
matching and hygiene), but exploits Java's compilation model to offer
a full procedural macro engine. In other words, syntax expanders may
be implemented in, and so use all the facilities of, the full Java
language.
Tom is a pattern matching compiler. It is particularly
well-suited for programming transformations on trees/terms or XML
documents. Tom can be used to develop transformation tools such as
compilers: The Tom compiler is written in Tom itself.
iContract is a novel Java(tm) tool that provides developers
with support for design by contract(tm). iContract is a freely
available sourcecode pre-processor which instruments the code with
checks for class invariants, pre- and postconditions that may be
associated with methods in classes and interfaces. Special comment
tags (e.g. @pre, @post) are interpreted by iContract and converted
into assertion check code that is inserted into the sourcecode. The
expressions are a superset of Java, compatible with a subset of the
latest UML ``Object Constraint Language (OCL)''.
SubJava is a pretranslator which enable one to use the
following possibilities: operator overloading, functions, global
constants and variables, implicit data type transformation.
EPP is an extensible Java source-to-source pre-processor which
can introduce new language features. The user can specify "EPP
plug-ins" at the top of Java source code in order to incorporate
various extension of Java. Emitted source codes can be compiled by
ordinary Java compilers, can be debugged by ordinary Java
debuggers. Plug-ins can extend the syntax of Java by extending the
recursive descend parser in a differential manner. EPP can also be
used as an application framework of source code manipulation tools
such as source level optimizer, metrics tools, obfuscating
tools.
JPP is a preprocessor that adds the following features to the
Java language: 1.Block closures 2.Local variable renaming
3.Operator overloading 4.Assert and trace macros 5.Conditional
compilation 6.Nested comments It does this by converting an input
.jpp file, into a standard .java file that is then compiled using
any standard Java compiler. The .jpp file contains normal Java
statements with syntactic extensions for the new features.
Jacl, pronunced "Jackal", is a Tcl interpreter written in Java.
You can use it for Java the same way Tcl is used for C -- a
scripting language to glue together modules written in a low level
language.
Sun wanted to create a new business group called SunScript to support the growing
Tcl community with an integrated development environment for Tcl
and a suite of products that link Tcl with the Web and Java
technologies. Meanwhile this seems to have moved to a company
called Scriptics.
Aardappel is a new language, which computes by concurrently
reducing trees (using a form of tree-rewriting) which sit together
in tree-spaces (bags) and communicate amongst eachother (exchanging
parts of themselves, in Linda-like fashion), and in general having
a jolly good time alltogether. The language is 100% graphical. Oh
yes, the language is linear as well.
Funnel is a new programming language based on Functional Nets.
Functional Nets combine key ideas of Functional Programming and
Petri-Nets to yield a simple and general programming notation.
PLAN is a resource-bounded functional programming language that
uses a form of remote procedure call to realize active networking.
PLAN is designed to be a public, authentication-free layer in the
Active Network hierarchy. For this reason, we have limited the
expressive power of PLAN in order to guarantee that all programs
will terminate, thus reasonably permitting a router to run any PLAN
program. However, PLAN can also be used as a "glue" layer which
allows access to higher-level services.
Jatha is a Java library that implements a fairly large subset of
Common LISP, including most of the datatypes (e.g. packages, bignums)
and their associated methods. The API allows programmatic access to
LISP from Java, either using an eval() method or using Java methods.
Additional LISP primitives can be written in Java and registered at
runtime to be used in the LISP interpreter. This one is different from the other Jatha listed here.
Bigloo is a Scheme implementation devoted to one goal: enabling
Scheme based programming style where C(++) is usually required. Bigloo
attempts to make Scheme practical by offering features usually
presented by traditional programming languages but not offered by
Scheme and functional programming. Bigloo compiles Scheme modules. It
delivers small and fast stand alone binary executables. Bigloo enables
full connections between Scheme and C programs, between Scheme and
Java programs, and between Scheme and C# programs.
(Use the version flagged as "Win32 precompiled version relying
exclusively on the JVM back-end" for JVM version. Please inform me if
you detect problems with its execution on platforms other than
Win32. RT)
SISC is an extensible Java based interpreter of the algorithmic
language Scheme. SISC is a complete implementation of the language.
The entire R5RS Scheme standard is supported. SISC can also interface
with Java through a bridge module called J2S.
PS3I, the Persistent Server-Side Scheme Interpreter,
is a nearly R4RS-compliant Scheme implementation, written in Java,
multi-users, multi-threaded and aimed to run on (Web-)servers (as
servlets).
The scheme package is a Java library implementation of the
scheme language. It is designed so that you can easily use it in a
Java application or applet to make it extensible.
HotScheme is a Java-based interpreter for the Lisp dialect
Scheme. It is intended as an exhibit of some of Java's power, a
tool that schools can use to supply students with a Lisp
interpreter, and, ultimately, an interactive Internet programming
environment.
webLISP is an experimental Implementation of reflective
functional Programming. It contains a very simple Lexer and Parser
for a lambda-calculus language in lisp-syntax. The Lambda terms are
compiled to variablefree Combinator Graphs. The virtual
Graph-Reduction-Machine that reduces the Combinator-graph
distinguishes between strict and non-strict operations. Strict
operations have to be evaluated even if we obey lazy evaluation and
can thus be evaluated in parallel to the main computation. The
parallel computations are added to a global task pool, which is
maintained by a stochastic scheduler. In addition to this basic
implemenation a special Combinator P is introduced which performs
an asyncronous parallelism of two given applications.
Skij is a Scheme interpreter written in Java. Its strong points
in comparision with other existing Scheme-in-Java implementations
are its small size and its facilities for manipulating Java objects
and controlling the Java environment. Skij includes extensions to
Scheme that permit fully interactive dynamic invocation of methods
on arbitrary Java objects; interfaces to threads and
synchronization; and support for writing UI event callbacks in
Scheme.Skij was designed to bring the hands-on interactive feel of
Lisp programming to the Java environment, and its primary use is as
a debugging, exploration, and scripting tool. It can also be used
for application development where speed is not critical.
Kawa (pronounced kava) is a compiler and run-time system for
Scheme written completely in Java. It generates Java bytecodes
using a "codegen" package which may be more generally useful. See
also
Byte-compilation of Scheme using Java byte-codes.
Jscheme is a dialect of Scheme with a very simple interface to
Java. It implements all of R4RS Scheme except that continuations
can only be used as escape procedures and strings are not
mutable.
The LispkitLISP compiler is written in SECD byte-codes. It
takes a LISP source file and compiles it into SECD byte-codes. The
SECD virtual machine is used to execute both the compiler and the
compiled programs.
A simple lambda calculus interpreter, using call-by-name
semantics. The language is pretty much Church's simple untyped
lambda calculus, the only concession for usefulness is the addition
of numbers.
The interpreter contains a functionally complete set of Lisp
primitives in less than two thousand lines of Java. It delegates
the implementation of higher level Lisp functions to Lisp itself,
thereby bootstrapping the interpreter to implement some of its own
functionality.
Lisp Interpreter in Java
A Lisp interpreter by Russ Ethington
A Scheme Interpreter in Java
Lisp Interpreter in Java
Lisp interpreter in java, working. but quite alpha
version.
A Scheme bytecode interpreter, in a preliminary release. It's
almost fully R4RS-compliant but otherwise minimal. It needs the
Boehm garbage collector to run. In an earlier incarnation this was
known as Plonk; there is an all-Scheme version, and a Java
implementation of the bytecode interpreter part. It's known to not
work right with JDK 1.1, and it will not be developed any
further.
Mapyrus is a BASIC-like language for creating plots of points,
lines, polygons and labels to PostScript (high resolution, up to A0
paper size), Portable Document Format (PDF) and web image output
formats.
With Convert 1.1 you can use your Visual Basic expertise to
create high-powered, sophisticated Java Applets and Applications.
Convert 1.1 is a GUI converter. Your VB screens are translated
directly into Java Source code.
JBasic is a (see note) embeddable BASIC interpreter written
entirely in Java. JBasic is designed for scripting Java Beans at
runtime. You can embed JBasic in any Java application, applet or
bean using the JBasic Runtime Engine. (NOTE: I have received a mail
from Mike Lehman referring to some legal stuff that this is not the
first embeddable BASIC - if you care about such important
notions...)
A simple BASIC interpreter written in Java. It's a primitive
BASIC, uses line numbers, implements most of BASIC-80. Note: I do not know why it uses the same name as the Cocoa Logo.
Mitch.Berger@gs.com commented on that: "Java as in coffee, is for
grown-ups. Basic 80 is a beginner's language, and Logo is aimed at
kids. It is therefore unsurprising to me that each has a version
named after a hot brown drink often given to children."
The applet is an interpreter for TRS-80 Model 1 Level 2 BASIC.
Note that it is a BASIC interpreter, not a TRS-80 emulator; thus,
the hardware-specific commands (PEEK, POKE, etc.) do not work.
StarLogo is a programmable modeling environment for exploring
the workings of decentralized systems -- systems that are organized
without an organizer, coordinated without a coordinator. With
StarLogo, you can model (and gain insights into) many real-life
phenomena, such as bird flocks, traffic jams, ant colonies, and
market economies. StarLogo is a specialized version of the Logo
programming language. With traditional versions of Logo, you can
create drawings and animations by giving commands to graphic
"turtles" on the computer screen. StarLogo extends this idea by
allowing you to control thousands of graphic turtles in parallel.
In addition, StarLogo makes the turtles' world computationally
active: you can write programs for thousands of "patches" that make
up the turtles' environment. Turtles and patches can interact with
one another -- for example, you can program the turtles to "sniff"
around the world, and change their behaviors based on what they
sense in the patches below.
Turtle Tracks is a modern Logo interpreter and runtime
environment written entirely in Java. It is not a direct port of an
existing interpreter, but written from the ground up specifically
for Java, and designed to take advantage of the strengths of Java
as a platform. Turtle Tracks is platform-independent and
Internet-ready, and supports numerous advanced features such as
multithreading and networking. Unlike some similar Java-based
projects, Turtle Tracks is a complete implementation of true Logo,
supporting the same basic language syntax and semantics and most of
the same primitives as other common Logo implementations such as
Berkeley Logo. It also supports plug-in primitive sets and can be
integrated with outside Java code as a scripting language.
Yoyo is a programming language loosely based on Logo. Since it
integrates Java, however, many of the more advanced features
require knowledge of Java and how its APIs work. (Was formely
called Bongo)
TermWare is a programming language, based on concept of term
system: set of rewriting rules with actions. It allows to unite logic
and imperative programming: TermWare actions can call Java objects via
reflection mechanism. The TermWare interpreter provides a Java API,
for embedding rule-rewriting into Java applications.
Drools is an augmented implementation of Forgy's Rete algorithm
tailored for the Java language. Adapting Rete to an object-oriented
interface allows for more natural expression of business rules with
regards to business objects.
More importantly, Drools provides for declarative logic programming
and is flexible enough to match the semantics of your problem
domain. The various parts that compose a rule may be extended to lend
domain-specific sense to the rule.
This Prolog was developped to be used the handle the knowledge and
reasoning needs of Java based Agents. It should be reasonably fast
and compact so that every agent could have its own KB and inference
engine.
tuProlog (2P) is a Java-based light-weight Prolog interpreter (and
related Java API) for systems engineering, suitable for open / dynamic
environment such as Internet applications and infrastructures. 2P
technology is an open-sourceproject.
An implementation of a Prolog interpreter, written in Java. It's
primary benefit is that can be run on almost any platform supporting
Java (such as a web browser), and as such it is well suited for
educational purposes. It works as both an application and as an
applet.
JIP - Java Internet Prolog is a cross-platform PureJava100%
prolog interpreter developed in JDK1.1 and supporting the prolog
Edinburgh syntax. By its API you can call your predicates written
in prolog in any java applet or application without dealing with
JNI and, vice versa, you can invoke java methods in your prolog
code as you call predicates.
NetProlog is a logic programming system that generates a binary
code, executable in the Java Virtual Machine (JVM). It follows
almost completely the syntax traditionally used in the ISO Prolog
implementations. For each logic predicate is generated a
corresponding Java class, which can be used as a regular code
generated for the JVM by any means.
CKI Prolog is a small but fine prolog implementation, running
under Java with less than optimal, but more than acceptable speed.
It was designed to be compatible with Sicstus, SWI and any other
prolog implementation. The current edition, beta4 , lacks floating
point and DCG, and some (non-essential) predicates are not
predefined. CKI prolog can handle operator notation, integer
arithmetic, lists, cut and dynamic assert/retract.
Jinni (Java INference engine and Networked Interactor) is a
new, lightweight, pure logic programming language, intended to be
used as a flexible scripting tool for gluing together knowledge
processing components and Java objects in networked client/server
applications and thin client environments. By supporting multiple
threads, control mobility and inference processing, Jinni is well
suited for quick prototyping of intelligent mobile agent
programs.
The language LLP is a logic programming language based on
intuitionistic linear logic. LLP is a superset of Prolog and a
subset of Lolli which is another linear logic programming language.
We are developing LLPj: A LLP to Java translator system.
jProlog is close to Clocksin-Mellish Prolog, with lots of the
typical builtins.You need a Prolog system (SICStus, BinProlog,
BIMprolog are ok - SWI doesn't work apparently)
Jess is a clone of the popular CLIPS expert system shell
written entirely in Java. With Jess, you can conveniently give your
applets the ability to 'reason'.
Prolog in java(javalog) ver 0.02. To avoid paradox, javalog
uses concept of world. You can make paradox in prolog. and
extension, you can make truth server. The world of internet will be
a single prolog interpreter. For data exchange, I used S
expression. You can exchange also Lisp server.
The project Bruce was a collaborative project between the
Microsoft Research Institute at Macquarie University in Sydney, and
Interactive Software Engineering (ISE) and aimed at developing an
Eiffel to Java Compiler. ISE thought about generating
Java Bytecode from EiffelBench.
This compiler allows Smalltalk to run on any JVM. The compiler
currently produces 100% Java class files fully compatible with the
Sun JVM specification. This allows Smalltalk and Java code to
interact seamlessly and allows Smalltalk programs to run anywhere
Java runs.
Talks2 is a full Smalltalk Development Environment which runs
on top of the Java Virtual Machine. It comes with a ClassBrowser,
Workspace, Transcript and all the things you know from a Smalltalk
Development Environment. Talks2 translates Smalltalk to Java, and
also uses the Java GUI and IO to run in any regular Java
environment. They have a strange Web-site which apparently can only be accessed with JavaScript enabled, so you have to click to Products and then to Talks2
Bistro is a new programming language that integrates features
of Smalltalk and Java. Bistro is a variation of Smalltalk that runs
on top of any Java virtual machine (VM) that conforms to Sun's Java
specifications. Bistro offers Smalltalk developers a means by which
to reuse the models they built with Smalltalk. Bistro provides
mechanisms for translating Smalltalk model code into Java, so that
models originally built with Smalltalk may be deployed on and
execute in a Java environment.
Its a dynamically and/or statically typed language (i.e. static
typing is optional, otherwise it defaults to dynamic typing) high
level scripting language for the JVM which compiles down to bytecode
either at run time or compile time. It features closures, neat List
and Map syntax, integrated markup language and expression language,
auto-boxing, operator overloading, mixins, AOP interceptors etc.
The homepage says: Nice is a new object-oriented programming
language based on Java. It incorporates features from functional
programming, and puts into practice state-of-the-art results from
academic research. This results in more expressivity, modularity and
safety.
From the author: "Anvil is dynamically compiled, modular,
procedural, object oriented and functional programming language with
semi-dynamic semantics. It has runtime typing but, for efficiency
reasons, static binding. It contains template engine for producing
tagged output, configurable server environment and own HTTP
listener. Any Java class can also be used directly. Anvil is
non-interpreted: all scripts and templates are compiled-on-the-fly and
executed as Java bytecode."
Ephedra is a C/C++ to Java migration tool. The tool reads C/C++
source code and transliterates it to Java source code. Though it
can convert most kinds of C/C++ source code, the focus is on C/C++
libraries that do not use any or much GUI code. The goals of the
transliteration are readability of the generated Java source code,
easy integration and interfacing with native Java code, little or
no user interaction during the transliteration process, good
performance, and basic C++ support.
dSelf is an extension to the delegation- and prototype-based
object-oriented language SELF. It adds distributed objects and
transparent remote reference resolution to the languages. As a
consequence, dSelf facilitates distributed inheritance and
instantiation mechanisms.
Hojo (Higer-Order functions & JavaTM Objects) is an
interpreted language, which provides a high-level, dynamic
interface to the Java Virtual Machine (JVM) on which it is run.
Hojo allows higer-order functions, contains full syntactical
support for collections, maps and arbitrary-precision numbers, and
provides a wide range of automatical type conversions, as well as
some additional built-in operators. The lexical syntax of the
language can be dynamically configured through a meta language,
such that e.g. custom operators can be defined.
Foo is a "new" language, and its interpreter. The main
caracteristics are: Full object-orientation, Dynamic message,
Written in Java, Full integration inside the JVM. It will be
usefull to write small scripts and to build quickly a prototype,
and it can be easily embedded inside any application.
The goal of the MetaJ project is the development of a generic
protocol-based self-applicative interpreter for Java. The basic
idea is to develop a generic reification procedure which can be
used to reify any class of the interpreter. Currently, we have
defined a reification scheme and we have built a reflective
interpreter from a non-reflective interpreter for an essential
subset of Java.
Demeter/Java allows you to write your Java programs in a much
more reusable form, called the adaptive form. You reuse all your
Java knowledge and learn a design language on top of Java. The two
important features of the design language are: Traversals and
Visitors. Demeter/Java enforces correct use of the Visitor Design
pattern in complex applications. The Visitor Design pattern is
directly supported in the executable design language which is on
top of Java.
Bolero is based on Java architecture. Like Java, Bolero is
strictly object-oriented. The Bolero Compiler generates Java byte
code directly, rather than taking the detour via source code. This
byte code can be ported across operating system boundaries, runs on
any platform for which a certified JVM is available ("write once,
run anywhere") and that is able to access a Bolero Application
Server, and supports component-based applications with distributed
or concurrent execution.
Sather is an
object oriented language designed to be simple, efficient, safe,
flexible and non-proprietary. One way of placing it in the "space
of languages" is to say that it aims to be as efficient as C, C++,
or Fortran, as elegant as and safer than Eiffel, and support
higher-order functions and iteration abstraction as well as Common
Lisp, CLU or Scheme. This compiler produces stand-alone
applications.
PERCobolTM Enterprise Edition is a robust COBOL development
solution enabling COBOL programs to execute on the Java Virtual
Machine (JVM). PERCobol is a fully ANSI 1985 X3.23b standard
compliant COBOL compiler which generates Java source code. The
resulting Java source code can then be compiled using any JDK 1.1+
compliant Java Compiler and will run on any JDK 1.1+ implementation
of the Java Virtual Machine as either an applet or application
depending upon how the program is invoked (applets are subject to
applet security restrictions).
An alternative to the Java language
for writing applets: a rich, tightly-standardized, dynamic
object-oriented programming language named Ada 95, and a translator
from Ada 95 to Java "Bytecodes". By translating Ada 95 to
Bytecodes, we make it compatible with Java and Java-capable
browsers.
The JGNAT system offers a complete Ada 95 development
environment for the Java platform. JGNAT comprises a compiler
generating Java bytecode that is compatible with Java virtual
machines conforming to Sun's standard (JDK 1.1 and above), and a
set of tools to aid in developing Ada programs for the Java
platform. (see also
ftp://cs.nyu.edu/pub/gnat/jgnat/)
Sleep is the Simple Language for Environment Extension Purposes. Sleep is a small language with perl-like syntax for integration into Java applications.
The attribute that makes Sleep different is it allows an application developer to develop "bridges". A bridge is a very simple class for adding new functions, predicates, operators, and even keywords for binding blocks of code. Sleep is easily extendable to make an application's features available to end-user scripters.
WLShell is an interactive command-line shell for BEA WebLogic
Server. WLShell provides simplified access to management beans
(MBeans) in WebLogic Server through a scripting language. If we think
of WebLogic Server as an operating system, WLShell can be considered
as a telnet program to access WebLogic.
Bambookit's XML-GUI controls are completely scriptable via the XML
tags. The XML scripts can be decomposed into smaller sections to
create a complete application.
JudoScript is a general-purpose, Java scripting, multi-domain
language. It is a general-purpose programming language, fully capable
of Java scripting, and supports many domain-specific features such as
JDBC scripting, XML scripting, ActiveX scripting and many more.
JRuby is the effort to recreate the Ruby interpreter in Java.
Currently, the interpreter is written in C. The Java version will
be tightly integrated with Java to allow both to script any Java
class and to embed the interpreter into any Java application.
ObjectScript is a weakly-typed general purpose object-oriented
programming language. It provides private fields and methods,
inheritance, exceptions, synchronization and threading, nested
functions and classes (nested scope), and operator
overloading.
Jickle is a language and runtime environment that allows
applications to provide unlimited user control. Jickle is similar
to a macro language for applications.
An interpreted C-like scripting language written in standard Java
that provides a high-level way to write applications that use AWT,
Swing, Java-2D, sockets, threads or other Java features. Familiar C
language elements such as printf, scanf and (safe) pointers aim at
making this language easy to learn and use.
Dawn is a dynamic scripting language based on RPN, supporting
dynamic naming to create variable and methods names from String,
scripts can dynamically override language default functions and the
language is based on a package set, with default ones io, err,
loops, test, util, math, stack, string
DynamicJava is a Java source interpreter executing programs
written in Java in addition with scripting features. DynamicJava
extends the Java grammar to accept many scripting features:
Statements and expressions can be written outside classes, at the
top-level. The variable declaration is optional. When the left part
of an assignment is an unknown identifier, a variable is defined.
The type of this variable is the type of the right part of the
assignment. The dynamic casts are optional. The package clause can
be used anywhere at the top-levelto set the current package. The
syntax of this clause has been extended : writing package; set the
current package to the anonymous package.
W4F is a toolkit for the generation of wrappers for Web
sources. It consists of a retrieval language to identify Web
sources, a declarative extraction language (HEL: HTML Extraction
Language) to express robust extraction rules and a mapping
interface to export the extracted information into some
user-defined data-structures.
NetScript is an environment for scripting with network
components. The NetScript environment's scripting language, which
is an extension of the BASIC programming language, is deliberately
kept simple, so the scripts are relatively easy to write and
modify. In NetScript, a developer selects required components from
a distributed catalog and then writes a script invoking methods on
the components as if the components are local. When a script is
launched, the NetScript run time determines component sites in the
network and transparently moves the script as needed.
Rhino is an implementation of JavaScript written entirely in
Java. The source code for Rhino is available under the NPL. e Rhino
project was started at Netscape in Fall 1997. At the time, Netscape
was planning to produce a version of Navigator written entirely in
Java and so it needed an implementation of JavaScript written in
Java. When Netscape stopped work on "Javagator", as it was called,
somehow Rhino escaped the axe (rumor had it that the executives
"forgot" it existed). Since then, a couple of major companies
(including Sun) have licensed Rhino for use in their products and
paid Netscape to do so, allowing us to continue work on it. Now
Rhino is planned to be part of several server products from
Netscape as well.
BeanShell is a small, free, embeddable, Java source interpreter
with object scripting language features, written in Java. BeanShell
executes standard Java statements and expressions, in addition to
obvious scripting commands and syntax.
PolyJsp is an extensible JSP implementation designed to support
multiple scripting languages and multiple JSP versions. Completely
based on XML and XSL, PolyJsp currently supports Java and
Javascript as scripting languages. Support is provided for the
latest JSP spec (0.92), with version 0.91 in the works.
Resin weaves Java components to HTML with JavaScript and the
Java Server Pages (JSP) interface. Resin conforms to the Servlet
interface and can be used with the major web servers, including
Apache. Amongst other features, it implements the bulk of ECMA-262,
the EcmaScript standard, implements JavaScript 1.3 features,
extends regular expressions with Perl 5 syntax and compiles scripts
directly to JVM bytecodes.
Iava is an interpreter that accepts a subset of the Java
programming language which includes method declarations, all block
statements, all statements and all expressions as specified by the
Java language. The interpreter does not accept class or interface
declarations. Iava is written in Java and can be embedded into any
Java application and applet. It offers highly effective integration
mechanisms (sharing of private fields between classes and scripts),
declaration of "methods" in a script which can be invoced by the
embedding application/applet, sharing of a "context" object to
which scripts can refer to using "this", etc.
WebL (pronounced "webble") is a scripting language for
automating tasks on the World-Wide Web. It is an imperative,
interpreted language that has built-in support for common web
protocols like HTTP and FTP, and popular data types like HTML and
XML.
FESI is a full implementation of the EcmaScript language,
defined in the standard ECMA 262 available at http://www.ecma.ch
(edition of june 97). EcmaScript is largely equivalent to the
JavaScript language version 1.1 or to the core part of JScript, but
without the navigator specific extensions.
iScript a platform independent scripting language written
entirely in JavaTM for creating scalable server side object
oriented n-Tier enterprise solutions.
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. Jython is the successor to
JPython.
Pnuts is a script language for Java environment. It enables
interaction with Java environment, simple GUI scripting, and
customization for Java programs.
Yassl is yet another extensible scripting language to work with
Java classes. Yassl is a non object oriented language with a syntax
that looks somewhat like C. Some of its features: Functions are
available as regular types, and can be passed around and embedded
in widgets. Implements lexical scoping, stolen from Scheme.
Variables are typed (but at this point, the interpreter does no
static type checking.) Eval is not directly supported, but an
instance of a Yassl interpreter can be created from within a Yassl
script, and you can evaluate expressions in the context of the new
interpreter instance.
This project is creating a superset of the Java language which is built on a process algebra, the join calculus. It provides the following features that are either absent or poorly supported in Java: * Asynchronous calls * Message passing *
A real inheritance for concurrency in Object Oriented programming Separating of concurrency from synchronization using abstraction Rigorous linkage with formal methods including join calculus, Petri nets and statecharts
Kanaputs is an interpreter for Java. With Kanaputs you can use
Java as an interpreted language: no more compilation, each instruction
is executed when you write it. Kanaputs allows to create Java objects
and call methods on them. The grammar of the Kanaputs language is very
close to the Java grammar. One big difference is that any variable
handled by Kanaputs is type-less. There is no variable declaration nor
type casting needed. Depending on the variable value, and where it is
used, Kanaputs chooses the best internal Java basic type and tries the
most appropriate type castings. When a variable handles a Java object,
its type is the class of the Java object. Another key feature of
Kanaputs is the reactivity. If the variable 'c' was defined like this
c = a + b; and if the reactivity of 'c' is set (c.reactive = true;),
each time the value of 'a' or 'b' changes then the value of 'c' is
updated as the result of the addition.
Jam is an extension of the Java language supporting mixins, that
is parametric heir classes. A mixin declaration in Jam is similar to a
Java heir class declaration, apart that it does not extend a fixed
parent class, but simply specifies the set of fields and methods a
generic parent should provide. In this way, the same mixin can be
instantiated on many parent classes, producing different heirs, thus
avoiding code duplication and largely improving modularity and
reuse.
JEX (Java Extension) is a programming language based upon Java
with built-in extensibility. JEX is a redefinition of Java using an
XML syntax. This allows programmers to extend their favorite
language. It also simplifies compilers, IDEs and code generators. With
JEX, a project is an XML document describing the various libraries,
classes, methods, etc. JEX provides a set of XSLT transformations to
generate the Java class files following the JVM specification.
The JMatch language extends Java with support for abstract
iterable pattern matching: a mechanism for pattern matching that is
compatible with the data abstraction features of Java and also makes
iteration abstractions convenient to use and to implement. JMatch
provides abstract pattern matching; patterns are not tied to algebraic
data constructors as in ML. A single JMatch method may be used in
several modes that may share a common implementation as a boolean
formula. JMatch provides modal abstraction that simplifies the
specification and implementation of abstract data types. JMatch also
makes the specification, implementation, and use of iteration
abstractions convenient, by automatically finding multiple solutions
to a formula or pattern.
Javassist (Java programming assistant) is a load-time reflective
system for Java. It is a class library for editing bytecodes in Java;
it enables Java programs to define a new class at runtime and to
modify a class file when the JVM loads it. Unlike other similar
systems, Javassist provides source-level abstraction; programmers can
modify a class file without detailed knowledge of the Java bytecode.
Jiazzi adds support for large-scale component programming in
Java. Components in Jiazzi contain, import, and export Java classes
and Java's in-language support for inheritance can be used across
component boundaries. The current implementation integrates into Java
using a linker, which manipulates components, and a stub generator,
which allows Jiazzi to be used with normal Java source
compilers. JJava code for a component is written using the normal Java
language and a separate linking language is used to manipulate
components.
Software architecture describes the structure of a system,
enabling more effective design, program understanding, and formal
analysis. ArchJava is an extension to Java that seamlessly unifies
software architecture with implementation, ensuring that the
implementation conforms to architectural constraints.
MultiJava is an extension to the Java programming language that adds
open classes and symmetric multiple dispatch. MultiJava retains the
modular static typechecking and compilation of Java.
Gilgul is an extension of Java that strictly separates the
notions of reference and comparison that are traditionally subsumed
in the concept of object identity. This allows for the introduction
of new operations that open up new degrees of flexibility during
runtime by providing means for unanticipated software evolution.
For example, Gilgul supports dynamic replacement of objects without
the need to explicitly deal with existing references.
Guaraná is a reflective architecture that aims at
simplicity, flexibility, security and reuse of meta-level code. It
features a run-time meta-object protocol that provides for easy
composition of meta-objects and allows for dynamic reconfiguration.
Meta-objects can be combined through composers, that provide the
glue code for them to work together, delegating control to them and
resolving conflicts when they arise. Since composers are
meta-objects, they can be further composed.
AspectJ is an aspect-oriented extension to Java designed to
simplify the development and maintenance of a wide range of
applications. AspectJ extends Java with aspects, which are a new
kind of programming construct that facilitates the implementation
of concerns that cross-cut a system.
PolyJ is a portable compiler that accepts an extended version
of the Java language. The PolyJ language includes support for
generic programming in the form of parameterized types. Like some
other proposals for adding genericity to Java, PolyJ provides
constrained parametric polymorphism. Unlike some, it uses the
constraint mechanism of where clauses, which is important because
it provides flexibility when composing a program. PolyJ also allows
all types to be used as parameters, even basic types like int. A
powerful feature of PolyJ is that instantiation types and parameter
types are first-class types that may be used wherever a type may be
used -- particularly, in safe run-time casts and with
"instanceof".
xkjc provides various Java language extensions, operator
overloading, and embedded SQL. It is an example for the
extensibility of the KJC
compiler suite.
The language Jass ('Java with assertions') is an extension of
Java by assertions. This concept is taken from Eiffel. It has been
developed by Bertrand Meyer as part of the concept "design by
contract" in order to develop correct software. For this purpose
the assertions are checked during runtime. If they are violated,
exceptions are triggered which can themselves be handled in the
program.
Borneo is a dialect of the Java language designed to have true
support for the IEEE 754 floating point standard. Java's
specification creates several problems for numerical computation.
Only a proper subset of IEEE 754's required features are supported
by Java; useful IEEE 754 features are either explicitly forbidden
or omitted from the Java specification. Java does not allow use of
the IEEE 754 recommended double extended format on the x86. Using
the double extended format often protects simple numerical formulas
from floating point anomalies. Strict adherence to Java's floating
point semantics leads to significant performance penalties on
popular architectures, including both the x86 and PowerPC. To
address these problems, the Borneo language changes and extends
Java so that all IEEE 754 features can be expressed and so that new
numeric types can be easily created.
Specialization classes are a Java language extension for
integrating forms of adaptive behavior in an existing program. An
adaptive class is defined by attaching a number of alternative
implementations to a regular Java class, that complement the
existing, default implementation. Each alternative implementation
is defined by a specialization class, and is to be used in some
specific situation. These situations are defined in terms of the
internal state of the (instances of the) class, via predicates on
the instance variables.
Poor Man's Genericity is an implementation of parameterized
classes (constrained parametric polymorphism) for Java. It is based
on a "lowest common denominator" design that can be implemented
easily on top of any existing Java compiler. We have implemented a
fully working compiler that has been built by reusing Sun's Java
compiler almost without modifications: only the way in which source
and byte-code files are loaded was changed to perform simple
transformations on loaded files.
GJ is an extension of the Java programming language that
supports generic types. GJ compiles into JVM code, so GJ programs
run on any Java platform, including Java compliant browsers. Class
files produced by the GJ compiler can be freely mixed with those
produced by other Java compilers.
Jamie is a preprocessor for Java that fills the gap between
interfaces and multiple inheritance. Jamie doesn't give you
multiple inheritance, though; it gives you multiple delegation
(i.e., it gives you subclassing without subtyping). Jamie is a
preprocessor that automates delegation. You run it on your code,
and it essentially produces the Java code you otherwise would have
had to write yourself.
Scriptic is a language extension that simplifies Java
programming. Scriptic includes the following: Simple and concise
constructs for expressing choice, parallelism, breaking, and
iterations. Simply write an ampersand instead of a semicolon: you
will get parallelism instead of a sequence, etc. Easy access to
multi-threading: Java code between {* and *} simply runs in its own
thread A refinement construct (script) with a powerful parameter
mechanism Communication between parallel processes using shared
scripts An event-driven execution mechanism that ideally suits user
interfaces, simulations, and others Scriptic has a strong
theoretical background in Process Algebra. This foundation means
that the language constructs for parallelism are well-defined.
OpenJava is an extensible language based on Java(TM). The
OpenJava MOP (Metaobject Protocol) is the extension interface of
the language. Through the MOP, the programmers can customize the
language to implement a new language mechanism. It is fully written
in Java of JDK 1.1, so it can be run on any platform which supports
Java Virtual Machine of JDK 1.1. And, the generated codes are
written in regular Java language, so the user's products can be run
on any platform which supports JVM of JDK 1.0 or JDK 1.1.
Here is the authors description: "Kiev is an extension of Java
language with parametriezed types, closures, multimethods, multiple
inheritance, extended syntax and semantic of loop and switch
statements and more. It also has an embedded, fully integrated AI
engine."
JavaParty is an extension of Java for transparent parallel and
distributed programming with remote objects and object mobility. It
can be pre-processed into regular Java plus RMI calls.
JAVAR is a prototype restructuring compiler that can be used to
make implicit parallelism in Java programs explicit by means of
multi-threading. JAVAR relies completely on the identification of
`implicit' parallelism by means of annotations.
JAVAB is a prototype bytecode tool that can automatically
detect and automatically exploit implicit loop parallelism in
bytecode, i.e. the architectural neutral instructions of the JVM.
Implicit parallelism is made explicit by means of the
multi-threading mechanism provided by the JVM.
Pizza is an extension of Java with parametric polymorphism,
first-class functions, and class cases and pattern matching. Pizza
compiles programs to ordinary Java Byte Code, and interfaces with
existing Java code.
DELTA Forth is a new Forth dialect and is intended to bring the
Forth programming language to the Java world. Unlike Forth, DELTA
Forth is a compiled language. This means that the source code is
turned into a special format that is used to execute the
program.
FIJI ForthIsh Java Interpreter, is written in Java and comes
with full GPL'ed source. Running either at a command line or in an
AWT window, FIJI accepts a syntax akin to the Forth programming
language and uses a reference stack to push and pop all params to
its functions. You can create Java objects and call methods on them
from the FIJI stack. FIJI is very preliminary, quite incomplete and
will be changing all the time. But such as it is, it works and has
been tested on Linux Blackdown JVM 1.1.7a, VM/ESA JVM 1.1.4, and
Windows/Sun JVM 1.1.7a.
Misty Beach Forth is an implementation of the Forth programming
language written in Java. Because it is written in Java, the Misty
Beach Forth interpreter can be embedded in a WWW HTML page and
launched as an applet.
ANTLR is a language tool that provides a framework for
constructing recognizers, compilers, and translators from grammatical
descriptions containing Java, C#, or C++ actions.
JavaCC is a parser/scanner generator for java. It is a
tool that reads a grammar specification and converts it to a Java
program that can recognize matches to the grammar.
FormsWizard is an automated migration engine that translates
Oracle Forms source code (PL/SQL) into Java language. It allows
companies and organisations to bring legacy software to the web and
achieve great savings compared to the cost of rewriting applications.
Zigzag is language of object-relational algebra for database and
data processing applications. Zigzag expressions reflect peculiarities
of Zigzag ORDBMS like multilevel and multi-valued attributes, data
integrity control, class inheritance, generalization (generation of
knowledge base).
Gardens Point Component Pascal (gpcp) is an implementation of
the Component Pascal Language. Component Pascal is Oberon
microsystems' refinement of the Oberon-2 language. Component Pascal
is a general-purpose language in the tradition of Pascal, Modula-2
and Oberon. Its most important features are block structure,
modularity, separate compilation, static typing with strong type
checking (also across module boundaries), type extension with
methods, dynamic loading of modules, and garbage collection.
JOMP is a research project whose goal is to define and
implement an OpenMP-like set of directives and library routines for
shared memory parallel programming in Java. The compiler translates
Java source code with directives to Java source code with calls to
the runtime library, which in turn uses Java threads to implement
parallelism.
A port of the GNU GCC compiler to the Java Virtual Machine
(JVM). Gcc emits assembler code (usually that fact is hidden from
the user); this port uses Jasmin as the "Java assembler". This
software is highly experimental.
Tea is a simple template language most commonly used for
creating dynamic web pages in the TeaServlet. Tea is a strongly
typed, compiled programming language, designed to work within a
Java-based hosting environment. Tea is designed to enforce a
separation between data acquistion and presentation, without
sacrificing basic programming constructs.
perljvm, the Perl to Java Virtual Machine (JVM) Compiler tries
to support the Perl language natively on the JVM without needing
the C perl system around.
f2j is part of a broader effort to provide computational
resources over the World Wide Web. The f2j project has two facets.
One is to emit as much compilable, verifiable, correctly running
Java source from Fortran source code, the other is to translate
Fortran to Jasmin assembler opcode for assembly into class files.
The f2j compiler is currently a special purpose tool, that is,
certain design decisions necessary to provide a general tool for
translating Fortran to Java have been postponed until working code
for the BLAS and LAPACK libraries has been emitted and tested.
C2J is a translator which translates C programs to Java
programs. C2J is available as native executable for Win32 platforms
as well as Java application which runs where Java Virtual Machine
is implemented (i.e. on Win32, Unix etc.). Standard ANSI C runtime
library fully supported. ANSI C and K"R C fully supported.
JAMES 007 is an graphical editor for Message Sequence Charts.
It aids in developing textual, but also graphical representations
of MSCs. Its special benefit is the generation of JAVA-Sourcecode
for a MSCs.
Andrew Myers' JIF (Java Information Flow) language provides
language-based information flow control with mostly-static
checking. Programs written in JIF can run on a standard JVM, but
the system requires certain runtime components to provide full
functionality. The goal of this project is to design and implement
the principals hierarchy, I/O channels, and other runtime
components required by the JIF system.
Coco/R is a compiler generator which takes a compiler
description in the form of an LL(1) attributed grammar and
generates the scanner and the parser of the described parser.
DB/C JX is a Java-based application development tool that
compiles the DB/C programming language into Java class files. DB/C
is an application development tool for the DB/C programming
language which is based on the ANSI Standard PL/B programming
language. The Java class files created by the DB/C JX compiler will
run in an Java 1.1 runtime environment, including web browsers,
network computers, handheld computers and traditional data
processing platforms.
Jcon is a Java-based implementation of the Icon programming
language. The Jcon translator, written in Icon, generates Java
class files that execute in conjunction with a run-time system
written in Java.
The term "SQLJ" refers to a series of specifications for ways
to use the Java TM programming language with SQL. The
specifications are in several parts: SQLJ: Embedded SQL -
Specifications for embedding SQL statements in Java methods. SQLJ:
SQL Routines - Specifications for calling Java static methods as
SQL stored procedures and user-defined functions. SQLJ: SQL Types -
Specifications for using Java classes as SQL user-defined
datatypes. A reference implementation of SQLJ has been provided by
Oracle.
The compiler is implemented in Java and generates plain Java.
The evaluation versions is time-limited and has some language
restrictions. An unrestricted version can now be ordered.
The compiler is implemented in Java and generates plain Java.
The evaluation versions is time-limited and has some language
restrictions. An unrestricted version can now be ordered.
The compiler is implemented in Java and generates plain Java.
The evaluation versions is time-limited and has some language
restrictions. An unrestricted version can now be ordered.
The AgentSheets environment is an agent-based Web authoring
tool enabling a wide range of end users, ranging from children to
professionals, to create their own SimCity-like interactive
simulations, domain-oriented visual programming languages,
knowbots, cellular automata, and games. At the the blink of an eye
these simulations can be compiled by the Ristretto compiler
directly into Java applets that can be embedded into web
pages.
JavAnimator is an animation applet generator for the Java VM
written entirely in Concurrent Clean, a functional language
developed at the Research Institute for Declarative Systems of the
University of Nijmegen. You can use JavAnimator to boost your WWW
pages with impressive animated applets.
Agora98 is implemented in Java and allows full access to the
underlying Java structures. This means that you are programming in
your webbrowser in Agora, and that you can dynamically access all
the API's of Java, and the entire Agora interpreter itself.
JEL is a library for evaluating a simple single line
expressions in Java. JEL compiles expressions directly to Java
bytecodes, allowing their fast evaluation.
MINERVA is a declarative language that inherits and combines
the advantages of Java and Prolog, resulting in a very practical
tool. MINERVA is implemented in Java and provides the core
functionality of ISO/IEC 13211-1.
E is a programming language designed for developers who write
distributed applications. It builds on the strength of Sun's Java
language, an open standard that already provides some flexibility
for developers writing World Wide Web applets. The E language
improves on Java's security model and provides other powerful
communications-oriented features. These include: distributed
communication, capability semantics, optimistic computation.
NetRexx is a new programming language derived from both Rexx
and Java(tm), written by the inventor of Rexx, Mike Cowlishaw. The
rules of syntax closely follow those of Rexx, while the semantics
often follow Java. It is a dialect of Rexx that can be as efficient
and portable as Java, while preserving the low threshold to
learning of the original Rexx language.
See also Visual
NetRexx as an IDE for NetRexx.
BAMBOO Language is a custmizable syntax, procedural
programming, interpreted, multi-process-executed,
GUI/telephony/database/network/mail programming supported
language.
Jamaica, the JVM Macro Assembler, is an assembly language for JVM
bytecode programming. It uses Java syntax to define a JVM class except
for the method body that takes bytecode instructions, including
Jamaica's built-in macros. In Jamaica, bytecode instructions use
mnemonics and symbolic names for all variables, parameters, data
fields, constants and labels. Jamaica is a simplified JVM assembly
language. It does not support inner classes. Variables are all
method-wide and are strongly-typed. Jamaica is a language facade for
a Java class creation API, JavaClassCreator. This API closely mimics
the Jamaica language, allows users to define a Java class with the
same flow, and supports all the Jamaica instruction set and
macros.
Jasmin is a Java Assembler Interface. It takes ASCII
descriptions for Java classes, written in a simple assembler-like
syntax and using the Java Virtual Machine instruction set. It
converts them into binary Java class files suitable for loading
into a Java interpreter. Jasmin was written as the companion to the
book "Java Virtual Machine", soon to be published by O'Reilly,
written by Troy Downing and Jonathan Meyer.
Jas
A java bytecode assembler. Java bytecode can be generated
either through a script which drives the assembler package, or
directly accessing the assembler package from java. The assembler
package is very simple, it attempts neither validation nor
optimization of bytecode.
Papers
Here are some papers on the implementation of programming
languages on the Java VM
Kava
is a backward-compatible extension to Java that allows a single object
model to be used consistently from the bit level on up, combining the
abstraction facilities of high-level object-oriented programming
languages with the ability to create highly efficient value types.
JLua is a
Java-implementation of the programming language Lua. Lua combines
simple procedural syntax with powerful data description constructs
based on associative arrays and extensible semantics. Lua is
dynamically typed, interpreted from bytecodes, and has automatic
memory management with garbage collection, making it ideal for
configuration, scripting, and rapid prototyping. A fundamental
concept in the design of Lua is to provide meta-mechanisms for
implementing features, instead of providing a host of features
directly in the language. For example, although Lua is not a pure
object-oriented language, it does provide meta-mechanisms for
implementing classes and inheritance. Lua's meta-mechanisms bring
an economy of concepts and keep the language small, while allowing
the semantics to be extended in unconventional ways. Extensible
semantics is a distinguishing feature of Lua.
![[new]](new.gif){kind=small}
icon. As proposed by Adam Kelly, links that currently point to nowhere
now carry a ![[new]](unclear.gif){kind=small}
icon. This means, that I would be very much interested to get
information on the new locations of these languages.