Programming Languages for the Java Virtual Machine (zt)

Posted on 2005-11-02 17:10 一条北极的鱼阅读(2547) 评论(0) 编辑收藏

http://www.robert-tolksdorf.de/vmlanguages.html

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 2005), it comprises close to 200 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.

The ObjectWatch Newsletter Number 33 of June 5, 2001 features an article "Is Java Language Neutral?" by Roger Sessions which does an in-depth analysis of the languages collected here. A reaction on that article is "Language Neutrality and the Java Platform" by Nik Boyd which is equally interesting.
Here is a fan of me :-)

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.

Robert Tolksdorf

New and changed entries

AMPC in category Various languages (12/10/05)
ABCL in category Lisp and co (11/10/05)
Snobol3 in category Various languages (09/27/05)
Grasshopper with VB.NET and C# in categories Basic and Various OO languages
Hecl in category Tcl (04/12/05)
Lili in category Lisp and co (04/12/05)
Infiqs Macro Expander in category Precompilers (03/17/05)
SmallWorld in category Smalltalk (01/31/05)
Flagged icontract and Jamie as unclear (09/17/04)
Flagged and Bruce as unclear (03/15/04)
Flagged Jas as unclear (05/03/03)

Comments? Leave you comments, remarks, and additions in the guestbook.

Precompilers

Infiqs: The Infiqs freeware macro-expander is a very-old-style operator-precedence compiler for assignment statements. It is meant to help programmers writing Java programs that use the BigDecimal class. It allows them to use infix operators for the arithmetic of BigDecimal.
Java+: Java+ is a Java preprocessor that supports multi-line strings with executable inclusions in Java as in Perl, Ruby, and Python.
A Simple Java preprocessor: Preprocessor with some commands.
Jatha: 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: 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: 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: 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: SubJava is a pretranslator which enable one to use the following possibilities: operator overloading, functions, global constants and variables, implicit data type transformation.
The extensible Java pre-processor EPP: 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 - A preprocessor for the Java language: 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.

Tcl

Hecl: The Hecl Programming Language is a high-level scripting language implemented in Java. Hecl is intended as a complement to the Java programming language, not a replacement. As such, it tries to do well what Java doesn't, and leaves those tasks to Java for which it is best suited. Core Hecl is small enough to run on my Nokia 3100 cell phone as a J2ME application.
Jacl: 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.
Tcl/Tk from Sun: 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.

Functional programming

Aardappel: 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: 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.
Mini: Mini is a very simple (half-functional) language written to test the ClassGen package of the JavaClass API.
PLAN - A Programming Language for Active Networks: 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.
Combinatory Logic Interpreter: An interpreter for the simplest language possible: both functions and data are represented by combinators, built up from S and K by application.

Lisp and co

Armed Bear Common Lisp (ABCL): Armed Bear Common Lisp (ABCL) is an implementation of ANSI Common Lisp that runs in a Java virtual machine. It provides a runtime system, a compiler that compiles Lisp source to JVM bytecode, and an interactive REPL for program development.
Lili: Lili is a new Lisp dialect, initially developped for using it as a sort of central executive or macro language in the Java - integration of an A.I. system called IPAL. There already exists a kind of 'reference'-interpreter implemented in Java (that incorporates some Lili-Java-interoperability features not inherent to the Lili language specification.).
Jatha: 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: 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: 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.
Lisp: A small Lisp implementation in Java
PS³I: PS³I, 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).
Scheme package: 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: 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: 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.
Jaja: Jaja is an implementation of Scheme in Java.
JScheme: JScheme is a hybrid language formed by combining the core syntax of Scheme with the objects, methods, and lexical structure of Java.
Skij: 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: 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: 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.
LispkitLISP Compiler: 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.
Lambda Calculus Interpreter: 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 UncommonLisp Interpreter: 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.
uts, the Useless Toy Scheme: 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.

Basic

VB.NET via Grasshopper: From the product description:
Grasshopper is a Visual Studio .NET® plug-in, which enables you to use C# or Visual Basic .NET® to develop, debug and deploy Web applications and Web services that run on Microsoft® Windows®, Linux® and any Java-enabled platform. Grasshopper introduces a patent-pending compiler that compiles Microsoft Intermediate Language (MSIL) into standard Java bytecode. You can access external Java components regardless of the Java development environment in which they were originally developed.
Testalgo2: A basic programation language
Mapyrus: 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.
MaVerickBASIC: MaVerick is an Open Source Multivalue Database Management System. It includes MaVerickBASIC, a DataBasic compatible compiler.
CONVERT: 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: 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...)
HotTEA - Basic written in Java: Mike Lehman's HotTEA is an implementation of the BASIC language written in Java.
JavaBasic: JavaBasic is a line command interpreter, loosely using the BASIC command set.
COCOA, the Java BASIC Interpreter: 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."
TRS-80 Model 1 BASIC Interpreter: 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.
Applet Designer: Applet Designer is a Visual Basic add-in that converts new or existing VB applications into Java applets.

Logo

StarLogo: 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.
AJLogo: AJLogo is an implementation of Logo written in Java with about 400 primitives.
Turtle Tracks: 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.
rLogo: rLogo is an easy to learn programming language designed for the World Wide Web. It is based on the Logo programming language.
Yoyo: 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)

Logic programming

TermWare: 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: Object-Oriented Rule Engine for Java: 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.
XProlog: 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: 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.
PROLOG+CG: PROLOG+CG is a logic programming language that integrates PROLOG, Conceptual Graph, Object-oriented programming and JAVA
DGKS Prolog: A prolog interpreter written in Java with an IDE.
JLog: 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: 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: 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: 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.
JavaLog: JavaLog is a Prolog interpreter written in Java(tm) designed to allow easy integration between Java and Prolog.
Jinni: 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.
LLPj: 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.
LL: LL is a Prolog like logic programming language. The documentation is in German.
W-Prolog: W-prolog is a simple Prolog interpreter written in Java. New version.
jProlog: 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, the Java Expert System Shell: 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'.
javalog: 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.
see also:: MINERVA
Kiev

ML

currently empty

Eiffel

Project Bruce: Translating from Eiffel to Java: 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.

Smalltalk

SmallWorld: SmallWorld is a public domain Little Smalltalk interpreter written entirely in Java. It is based on the Little Smalltalk system, which was the first Smalltalk interpreter written outside of Xerox Parc, back in 1984.
SmalltalkJVM: 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: 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: 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.

Various OO languages

C# via Grasshopper: From the product description:
Grasshopper is a Visual Studio .NET® plug-in, which enables you to use C# or Visual Basic .NET® to develop, debug and deploy Web applications and Web services that run on Microsoft® Windows®, Linux® and any Java-enabled platform. Grasshopper introduces a patent-pending compiler that compiles Microsoft Intermediate Language (MSIL) into standard Java bytecode. You can access external Java components regardless of the Java development environment in which they were originally developed.
G: The documentation names these features: G is a superset of Java, G and Java can work together, Variable types are implied when declared and initialized, Automatic type casting, Store and send functions as parameters, Script classes, context, loading and calling, Template Strings: Strings with embedded expressions, Dynamic Dispatch: Runtime method invocation and field access
Groovy: 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.
Nice: 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.
Scala: Scala is a general purpose programming language with a special focus on web services. It combines object-oriented, functional and concurrent elements.
Anvil: 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: 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: 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: 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: 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.
Correlate: Correlate is a concurrent object-oriented language with a metalevel architecture that makes it easier to develop distributed programs
MetaJ: 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: 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: 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: 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.

COBOL

PERCobol: 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).

Ada

AppletMagic: Ada for the Java Virtual Machine: 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.
JGNAT Ada 95: 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/)

Scripting

FScript: FScript is a simple scripting language. Its intended use is as an embedded language in other Java programs. It is very simple to embed - it can be as simple as sub-classing one class to add your own functionality. However is not a complete programming language, as it has no library of standard functions (such as IO and string processing). FScript supplies a base functionality (such as flow control, variable handling and basic math operations) that can extended by the host application. As of version 1.1 it is possible to access Java objects from within a FScript script.
Sleep: 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: 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: 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: 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: 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: 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 - Java Control Language: Jickle is a language and runtime environment that allows applications to provide unlimited user control. Jickle is similar to a macro language for applications.
Yoix: 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.
Simkin: Simkin is a high-level lightweight embeddable scripting language which works with Java[tm]/XML or C++.T
Bean Scripting Framework (BSF): The Bean Scripting Framework (BSF) is an architecture for incorporating scripting into Java applications and applets.
Dawn: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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, a Free EcmaScript Interpreter: 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: iScript a platform independent scripting language written entirely in JavaTM for creating scalable server side object oriented n-Tier enterprise solutions.
Jython: 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: Pnuts is a script language for Java environment. It enables interaction with Java environment, simple GUI scripting, and customization for Java programs.
Yassl: 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.
see also:: The NetRexx Language

Extended Java

Join Java: 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: 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: 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: 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.
JMatch: 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: 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: 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.
ArchJava: 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: 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: 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.
dejay: Dejay is a dialect of Java that simplifies the development of distributed software applications.
Guarana: 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: 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 - Java with Parameterized Types: 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: xkjc provides various Java language extensions, operator overloading, and embedded SQL. It is an example for the extensibility of the KJC compiler suite.
Jass - 'Java with assertions': 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: 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 for Java: 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 for Java: 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: 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: 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: 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: 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.
Kiev: 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: 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: 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: 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: 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.

Forth

myForth: myForth is a basic Forth interpreter written in Java. Forth programs can be read from Java Applet parameters.
A Forth Interpreter in Java: A Forth interpreter implemented in Java
Delta Forth: 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: 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: 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.

Various languages

AMPC: Axiomatic Multi-Platform C (AMPC) is a C Integrated Development Environment (IDE) that generates Java Bytecode. AMPC allows users to develop software using the standard C programming language and run the executables on any JVM enabled system.
Snobol3: A Snobol 3 interpreter implemented in Java
Processing: Processing is a programming language and environment built for the electronic arts and visual design communities. It is created to teach fundamentals of computer programming within a visual context and to serve as a software sketchbook. It is used by students, artists, design professionals, and researchers for learning, prototyping, and production.
Qexo: Qexo is a partial implementation of the XML Query language. It achieves high performance because a query is compiled down to Java bytecodes using the Kawa framework.
Frink: From the description: "Frink is a practical calculating tool and programming language designed to help us all to better understand the world around us, to help us get calculations right without getting bogged down in the mechanics, and to make a tool that's really useful in the real world."
ANTLR, ANother Tool for Language Recognition: ANTLR is a language tool that provides a framework for constructing recognizers, compilers, and translators from grammatical descriptions containing Java, C#, or C++ actions.
Java Compiler Compiler: 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: 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: 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).
Pipes for NetRexx and Java: Pipes for NetRexx and Java implements a simple but very powerful piping methodology based on the one developed by John P. Hartmann of IBM.
XSLTC: The XSLT Compiler is a Java-based tool for compiling XSLT stylesheets into lightweight and portable Java byte codes called translets.
Component Pascal: 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: 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.
Tea: 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.
Tiger: Tiger is an example language from the book Modern Compiler Implementation in Java by Andrew W. Appel
perljvm: 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.
Fortran 2 Java (f2j): 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.
JAMES 007: 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.
Java Information Flow: 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: 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: 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: A Java-Based Icon Implementation: 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.
SQLJ - Embedded SQL 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.
Canterbury Pascal for Java: 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.
Canterbury Oberon-2 for Java: 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.
Canterbury Modula-2 for Java: 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.
AgentSheets: 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: 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.
Luck: Luck is a simple language which is compiled into Java code. Newest version 3.0
JOI - The Java Occam Interpreter: JOI is an Occam interpretation system coupled with a compiler that produces Jasmin based assembly language ready to be converted to Java byte code.
Agora98: 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.
Java Expressions Library: 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: 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.
The E programming language: 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.
The NetRexx Language: 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 Home Page: BAMBOO Language is a custmizable syntax, procedural programming, interpreted, multi-process-executed, GUI/telephony/database/network/mail programming supported language.

Assemblers

Jamaica: The Java Virtual Machine (JVM) Macro Assembler: Jamaica, t

充分的利用你的JVM吧。

新用户注册刷新评论列表


只有注册用户登录后才能发表评论。




网站导航: 博客园 IT新闻 Chat2DB C++博客博问管理

一条北极的鱼