K is for ...

kew

is a powerful but small object-oriented programming language that offers many advanced features, including proper closures, first-class variables, relations, continuations, exceptions, dynamic variables, security, transactions, persistence....

It is based on ideas drawn from many contexts, including Smalltalk, Scheme, Miranda, RDF (yes, the XML thing), Java. It has a small footprint and a concise API that makes it ideal for embedding in other programs, and a powerful security model that makes it good for writing applets.

Kevo

A Forth-like concatenative prototype-based object-oriented programming language.

Key

Not satisfied by the versatility of existing programming languages, Patrick Soquet decided to develop Key, a dynamic language that allowed both class abstraction and object description. Today, after more than 10 years of language and tool development, Key is at the heart of software developed and published by Tribeworks and is used daily throughout the world to produce software for PCs, interactive terminals, and CD-ROMs.
According to Patrick Soquet, co-founder of Tribeworks, "Programming languages are not neutral. They condition application design and development. The characteristics of Key allow you to work in a manner that is entirely different from Java or C#. At a time when everyone is claiming this or that standard, it's satisfying to deliver with a truly open alternative!"

KiXtart

is a logon script processor and enhanced batch scripting language for computers running Windows XP, Windows 2000, Windows NT or Windows 9x in a Windows Networking environment.

Kogut

Kogut is an experimental programming language which supports functional and scripting-style programming, and a non-traditional flavor of object-oriented programming. Its semantics is most similar to Scheme or Dylan, but the syntax looks more like ML or Ruby.

The name "Kogut" means "Rooster" ("Cock") in Polish and is pronounced like [KOH-goot].

Almost half way: F to J

This list of programming languages was originally on a short-lived weblog called, "Bruce the Goose". Then it appeared down the left-hand side of Code-a-holic.

Over the next few weeks I'll be posting the rest of the data I have on those languages (the bare minimum of name, link, and description.) If anyone's interested in the metacard database or having an XML-ish file with all of the extra details (platform, users' group, date of last activity, etc.), please leave a comment.

Leave a comment too, if you can see anything that needs changing / updating.

F is for ...

ferite

is a scripting engine and language written in c for complete portability. ferite is a scripting language and engine all in one managable chunk. It is designed to be easily extended in terms of API, and to be used within other applications making them more configurable and useful to the end user. It has a syntax similiar to a number of other langauges but remains clean and it's own language. Even though ferite started out as a pet project it has slowly evolved into a powerful engine that is useful and applicable to a lot of areas. There are just a few very strong goals that will be followed: a cross platform clean usable language, clean interaction with the native world and good support for existing and up and coming standards.

ficl

is a programming language interpreter designed to be embedded into other systems as a command, macro, and development prototyping language. Ficl is an acronym for "Forth Inspired Command Language".

friend

FRIEND is an experimental compiler and interpreter written by Andrei Goumilevski with purpose to learn about lex and yacc while in Ottawa, Canada

1. Compiler/interpreter for a simple OO language. The language allows to use networking very easily, including such protocols as TCP, UDP, Raw Sockets
2. Library for reading/manipulating Java bytecode

fscp

This is only preview version, that may be used *ONLY* for embedding */bin/sh* (or your default shell) scripts into web pages.

ftwalk

is a high level script programming language, very similar to awk, but greatly extended to include a richer type system, object-oriented features, 300+ built-in functions, extensibility through dynamic libraries, etc., which makes it roughly comparable to languages like Perl. It does file tree searches, and was originally used to implement selective redundant copy backup stores. It can be run interactively as a calculator.

F-script

is a lightweight object-oriented interactive and scripting layer specifically designed for the Mac OS X object system (i.e. Cocoa). F-Script provides scripting and interactive access to Cocoa frameworks and custom Objective-C objects. It aims to be a useful and fun tool for both beginners and experts, allowing interactively exploring, testing and using Cocoa-based objects and frameworks.
Based on Smalltalk, F-Script provides a pure object-oriented environment that leverage Mac OS X technologies and includes significant innovations, like a high-level model for object manipulation and the most terrific object browser on earth!
F-Script is used in various fields including astrophysics, biology, music analysis, game development, software debugging, etc. It can be used as a stand-alone application that dynamically loads your Objective-C classes and enables you to access them either interactively or using scripts. It can also be embedded into your own applications thanks to a set of components which are extremely easy to use (for excellent examples of this see Charla 2 , a Yahoo! chat client for Mac OS X, and LSQL , an interactive tool for Sybase Adaptive Server).

FALSE

The language FALSE and it's compiler were designed for only two reasons:
- building a working compiler in just 1k (!)
- designing a language that looks cryptic and fuzzy (in the APL tradition)

the result is a language that is quite powerfull (for it's size).
It's a Forth type language with lambda abstraction and lots of other goodies.
I named the language after my favourite truthvalue.

FAST

FAST is a new programming language, which combines the advantages of other programming languages:

• FAST supports functions as data types
• FAST is fully object-oriented and knows multiple inheritance
• FAST has dynamical memory management and garbage collection
• FAST includes library units on its own
• FAST speaks Assembler
• FAST knows macros
• FAST has a clear and consequent syntax
• FAST compiles within tenths of seconds and creates efficient code
• FAST has lots of useful features such as e.g. the prevention of the Division by Zero error

FAST programs are written as plain text and then sent thru the FAST compiler. Small and efficient code is created and a COM-File results. Up to now, FAST only compiles for MS-DOS (I just have not yet found out how to assemble a binary executable for WINDOWS).

FBSL

is my Free Basic Script Language :)FBSL was inspired from the Batch (.BAT) script language established within Microsoft Windows Operating System.

FIJI

FIJI is a forth-like interpretive procedural language which is in reality a Java interpreter. You can load and excercise Java classes interactively in FIJI, or you can compile FIJI programs to do so.
FIJI is an open source project licensed under the GNU Public License.

FISh

FISh is a new array programming language that combines (and extends)the
EXPRESSIVE POWER
of functional programming with the
EFFICIENT EXECUTION
of imperative, or procedural, programming by performing
STATIC SHAPE ANALYSIS
on all programs. This shape computation reduces higher-order functional programs to simple imperative forms, i.e. F - Sh = I. Conversely, FISh works best when functions are constructed from imperative procedures and shape functions, as recommended by the slogan that gives the language its name.
Functional = Imperative + Shape
FISh execution speeds on typical array problems are several times faster than otherhigher-order, polymorphic languages.

FastScript

is cross-platform multi-language scripting engine. It is useful for the programmers who want to add scripting ability to their projects. FastScript is written on 100% Object Pascal and can be installed in Borland Delphi 4-7, C++Builder 4-6 and Kylix 1-3. Unique feature of FastScript is ability to use several languages (PascalScript, C++Script, JScript and BasicScript), so you can write scripts using your favourite language. FastScript doesn't use Microsoft Scripting Host, so it can be used in Windows and Linux environment. It is possible to add a new language - language definition is stored in the XML format, so you can perform it without writing a Delphi code.

Flavor

( Formal Language for Audio- Visual Object Representation) is an object-oriented media representation language being developed at Columbia University . It is designed as an extension of Java and C++ and simplifies the development of applications that involve a significant media processing component (encoding, decoding, editing, manipulation, etc.) by providing bitstream representation semantics.
Flavor is used in the ISO/IEC MPEG-4 standard for the representation of the bitstream syntax. The software for the Win32 platform is readily available as part of the Flavor package for translating the Flavor description into C++ or Java code. Additionally, since Version 5.0, the software is enhanced to support XML features. The source code along with scripts and project files are also available so that the binaries for different platforms can be built.

Force

is designed to combine the advantages of well-known languages, like xBase and C. Force has a high-level syntax similar to xBase, and offers built-in database services according to the xBase standards. Unlike xBase, however, Force generates native code that is small and fast like C programs. In addition, the Force language has low level constructs (pointers, structures, etc.) and library services that appoint it to be a uniquely wide spectrum development tool, useful for writing virtually any sort of programs, from business applications to TSR utilities.

ForthEC

ForthEC is a Forth compiler written in Euphoria. It generates x86 assembly code, which can be assembled and linked into Win32 executables using MASM32.

FramerD

is a portable distributed object-oriented database designed to support the maintenance and sharing of knowledge bases. Unlike other object-oriented databases, FramerD is optimized for the sort of pointer-intensive data structures used by semantic networks, frame systems, and many intelligent agent applications. FramerD databases readily include millions of searchable frames and may be distributed over multiple networked machines. FramerD includes an extensive scripting language based on Scheme with special support for web-based interfaces.FramerD is implemented in ANSI C and has been compiled for a wide range of platforms, including many varieties of Unix and WIn32. In addition, experimental Java and Lisp libraries exist for accessing FramerD databases and services.

Frogbit

Frogbit is the name of both a programming language and of the tools used to develop programs written in it.
It is a small programming language which is designed for the manipulation of files and text. The syntax of the language is largely based on the use of keywords rather than punctuation; this means that Frogbit programs tend to be large but readable.
A well-featured IDE (integrated development environment) is provided for the development of Frogbit programs. The IDE has facilities for running, single-stepping and halting your program and also supports breakpoints, expression watches and file-view windows so that you can track intermediate results.

Funnel

is a 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. They have their theoretical foundation in Join calculus .
Read our introduction to learn more about Functional Nets and Funnel. Our Overview of Functional Nets is the latest document describing Funnel.
The first prototype implementation is Funnel0, a dynamically typed version of Funnel. Funnel1 incorporates an experimental type system. This statically typed version of Funnel is introduced with release 5. The current release includes development tools for both dialects.
Funnel0 and Funnel1 programs are compiled into Funnel bytecodes. A virtual machine is executing these bytecodes. Both the compiler and the runtime system are implemented in Java . Therefore Funnel will run on any platform which has at least a Java Runtime Environment 1.2. Funnel programs itself can access the full Java API. The latest funnel compiler is also able to compile Funnel directly to Java bytecodes.

J is for ...

japi

is a library for Graphical User Interfaces (GUI). It was designed for quick and dirty use, cause its NOT object oriented. Therefor, it's easy to learn. Even beginners with little experiences in programming are now able to write first applications with graphical user interfaces.
The main goals of are:

• Easy to learn and use.
• Language independend. Currently can be used with Basic, C, Fortran and Pascal.
• Platform independent. Written on one platform, the application should run on another platform through recompiling. Supported platforms are currently all Win32, Linux and Solaris.

JAPI is build on top of the AWT. The AWT (abstract windowing toolkit) is part of the freely distributed Java Developer Toolkit (JDK). The AWT is composed of a package of classes and it supports everything from creating buttons, menus, and dialog boxes to complete GUI applications. Notable, the AWT is platform indepented.
The functionality of the AWT is now brought to the (classic) programming languages via . So you do not need to learn JAVA. All you need is a running Java Runtime Environment (JRE) on your host.

jerboa

.

JACL

is an interpreted computer language originally designed for programming text adventure games. Its migration to the web now allows the author to create a much wider variety of graphical and non-graphical programs, all of which can be used online using nothing more than a standard HTML web browser.

Jargon

is a message based programming language. Execution of a Jargon program begins in the "Main" module in the "main" handler, which takes an array of strings as input. Variables and modules must be declared before use. However, handlers may be declared at any point within the module in which they reside. Jargon supports single inheritance of modules and overloaded message handlers.

JokerTool

is a MacOS X command-line tool that can execute scripts written in the scripting language HyperTalk. HyperTalk is a very english-like high-level language.

Jolt

Like every other programmer with a pulse, I am compelled to create my own programming language. My compulsion is fueled by my day job, where I must deal with million line C++ programs. Jolt is the language in which I wish I could be programming.
Jolt is a system programming language intended to be used anywhere one would use C++. It is as willing to get dirty in the name of performance. It is not willing to compromise in the name of compatibility with legacy languages. It is a language in which everything is an object, inheriting from Object, including the primitive types, and yet is capable of implementing many of these same types in itself. It includes features traditionally seen in dynamically-typed object-oriented languages such as Ruby, and even has some LISP features, yet does so in a way that preserves strong static typing and the performance benefits thereof.
At the very least, the people who gripe that every new language looks like C++ or Java but with really neat feature X or minus really evil feature Y and why can't someone come up with something not so derivative... whatever faults they may find with Jolt that won't be one of them.
The current language specification may be found here. While it's meant to be an introduction and reference, it suffers from the stream-of-consciousness brain dump syndrome. I'll need to do an overhaul someday, but at over 120 pages (when formatted for printing) and growing, right now that would take too much time away from implementing the compiler.
Speaking of which, I have completed the parser and am starting on the semantic processing. If nothing else, this proves the grammar is LALR(1) with a minor exception or two. While I am not releasing any code at this time, I plan on eventually doing so under the GNU GPL.

Joy

is a purely functional programming language. Whereas all other functional programming languages are based on the application of functions to arguments, Joy is based on the composition of functions. All such functions take a stack as argument and produce a stack as value. Consequently much of Joy looks like ordinary postfix notation. However, in Joy a function can consume any number of parameters from the stack and leave any number of results on the stack. The concatenation of appropriate programs denotes the composition of the functions which the programs denote. One of the datatypes of Joy is that of quoted programs, of which lists are a special case. Some functions expect quoted programs on top of the stack and execute them in many different ways, effectively by dequoting. So, where other functional languages use abstraction and application, Joy uses quotation and combinators -- functions which perform dequotation. As a result, there are no named formal parameters, no substitution of actual for formal parameters, and no environment of name-value pairs. Combinators in Joy behave much like functionals or higher order functions in other languages, they minimise the need for recursive and non-recursive definitions. Because there is no need for an environment, Joy has an exceptionally simple algebra, and its programs are easily manipulated by hand and by other programs. Many programs first construct another program which is then executed.

Juliet

Juliet is an open source programming language that I am designing. I am currently designing a compiler for Juliet called JULC, written in C++. The source code to JULC is freely available as described in its Readme file. Old versions of everything on this page are available in the Juliet Archive.

I is for ...

ibal

"... (pronounced "eyeball") is a general-purpose language for probabilistic modeling, parameter estimation and decision making. It generalizes Bayesian networks, hidden Markov models, stochastic context free grammars, Markov decision processes, and allows many new possibilities. It also provides a convenient programming-language framework with libraries, automatic type checking and so on."

inform

A Design System for Interactive Fiction

Just as film might be called a form of literature which needs technology to be read (a cinema projector or a television set) and to be written (a camera), interactive fiction is read with the aid of a computer. On this analogy, Inform is a piece of software enabling any modern computer to be used as the camera, or the film studio, to create works of interactive fiction. To read the resulting works, you and your audience need only a simpler piece of software called an interpreter.

In this genre of fiction, the computer describes a world and the player types instructions like touch the mirror for the protagonist character to follow; the computer responds by describing the result, and so on until a story is told.

Interactive fiction emerged from the old-style "adventure game" (c.1975) and tends to be a playful genre, which must sometimes be teased out as though it were a cryptic crossword puzzle. But this doesn't prevent it from being an artistic medium, which has attracted (for instance) the former U.S. Poet Laureate, Robert Pinsky, and the novelists Thomas M. Disch and Michael Crichton. An interactive fiction is not a child's puzzle-book, with a maze on one page and a rebus on the next, but nor is it a novel. Neither pure interaction nor pure fiction, it lies in a strange and still largely unexplored land in between.

Since its invention (by Graham Nelson in 1993), Inform has been used to design some hundreds of works of interactive fiction, in eight languages, reviewed in periodicals ranging in specialisation from XYZZYnews to The New York Times. It accounts for around ten thousand postings per year to Internet newsgroups. Commercially, Inform has been used as a multimedia games prototyping tool. Academically, it has turned up in syllabuses and seminars from computer science to theoretical architecture, and appears in books such as Cybertext: Perspectives on Ergodic Literature (E. J. Aarseth, Johns Hopkins Press, 1997). Having started as a revival of the then-disused Infocom adventure game format, the Z-Machine, Inform came full circle when it produced Infocom's only text game of the 1990s: Zork: The Undiscovered Underground, by Mike Berlyn and Marc Blank.

ImageScript 2

is a programmers tool to convert, resize, copy and move bmp, gif and jpg images under control of a script that you can create from e.g. Delphi, VB, MS Access 97 etc. NEW: png and tif support, add (angled) text, add grid lines.

Indie

The Indie language is an effort to provide the runtime features of modern languages, including type safety and garbage collection, without the overhead of a runtime executable like the Java Virtual Machine. The hope is this will let us use Indie in lower-level system code and other areas where (today) only C is prevalent.
The Indie programming language is designed to be a safe alternative to C and C++. It is designed to have the feel of Java, but with features that make it easy to analyze and compile to native code efficiently. Indie's unique type system makes it easy to create generic, reliable components without incurring significant runtime type safety costs.

Io

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

Ivy

is an embeddable byte-code compiled/interpreted language whichis useful as both an extension and a command language. Its syntax isdesigned to be easy to learn and to be fairly good looking. Ivy currentlysupports four data types: integers, strings, functions and objects. Objectsare late-binding storage devices which take the role of arrays, structuresand simple look-up tables. Floating point or arbitrary length floatingpoint numbers will be available in a future implementation. Ivy comespackaged as an interactive language like BASIC and LISP. You can eitherexecute language statements immediately from the keyboard or run a programstored in a file. Ivy is also easy to embed into another program. Callsare provided to execute Ivy code and to add C function extensions to Ivy'sinterpreter.

H is for ...

hop

Dynamic binding denotes a family of programming constructs where the runtime systemincludes some notions of \" and \" (associations from names to values),and where the operation of looking up some name in some environment is performeddynamically. A number of popular languages use dynamic binding, under various forms:quote and eval in LISP, stacks of dictionaries in FORTH or Postscript, message send inobject-oriented languages. However, functional programming languages (FPLs) such asML [MilToHa90] or Haskell [Hudak92] do not support it. This is because some of thekey aspects of these languages, like parametric polymorphism, higher-order composition,type inference or pattern matching are not easy to combine with dynamic binding. Nevertheless,we argue that at least some level of integration is possible, as demonstrated byour research language HOP . The main issues in terms of language design, underlyingexecution model and type inference are discussed here.

Heron

is a brand new open source, general purpose, imperative programming langauge. Heron is a language that focuses on facilitating the production of code that is efficient, low in defects and highly reusable. Heron supports several software development techniques and methodologies, including, but not limited to, object oriented programming (OOP), aspect oriented programming (AOP), generic programming , design by contract (DbC), metaprogramming , and interface oriented programming (IOP). The Heron syntax intentionally resembles a mix of C++ and Java, to be familiar and easy to learn for programmers familiar with the syntax of these language.

Homespring

is a bizarre programming language in the spirit of INTERCAL and Befunge. It is designed to superficially resemble English, but hide beneath it a structure so needlessly complicated and ridiculously impractical that it brings tears to the eyes. Instead of being an excessively low-level language, like most of these efforts are, Homespring aims to be excessively high-level, as you shall see.

Hope

is a small functional programming language, with polymorphic typing, algebraic types, pattern matching and higher-order functions. The version here is a fully lazy interpreter.

G is for ...

goo

is a new dynamic type-based object-oriented language. It is meant to be simple, productive, powerful, extensible, dynamic,efficient and real-time. It heavily leverages features from manyearlier languages. In particular, it attempts to be a simplerlisp-syntaxed Dylan, an object-oriented Scheme, and a lispified Cecil. GOO's main goal is to offer the best of both scriptingand delivery languages while at the same time incorporating anextreme back-to-basics philosophy.

Gödel

is a declarative, general-purpose programming language in the family of logic programming languages. It is a strongly typed language, the type system being based on many-sorted logic with parametric polymorphism. It has a module system. Gödel supports infinite precision integers, infinite precision rationals, and also floating-point numbers. It can solve constraints over finite domains of integers and also linear rational constraints. It supports processing of finite sets. It also has a flexible computation rule and a pruning operator which generalises the commit of the concurrent logic programming languages. Considerable emphasis is placed on Gödel's meta- logical facilities which provide significant support for meta-programs that do analysis, transformation, compilation, verification, debugging, and so on.

GIMI

the Graphical Interfaced Multitasking Interpreter. One of the few GUIs made in QuickBASIC featuring multitasking. This one has its own script language for making programs, damm fast SVGA modes, lots of programs, and more!

GOFOLIO

the programming language for the ATARI portfolio

For the development smaller to medium sized programs.

Compilers and programs run on the portfolio and each PC.

Gofolio runs on the portfolio under all BIOS versions and without memory expansion.

Programming language for structured programming, which can be learned easily.

Gofolio runs very stably and fast on the portfolio.

Is particularly suitable for the hardware near programming of control -, measuring and regulation programs.

Gofolio support real numbers.

GPP

is a general-purpose preprocessor with customizable syntax, suitable for a wide range of preprocessing tasks. Its independence from any one programming language makes it much more versatile than the C preprocessor (cpp), while its syntax is lighter and more flexible than that of GNU m4. There are built-in macros for use with C/C++, LaTeX, HTML, XHTML, and Prolog files.

GYS

is the scripting engine which helps to create the embedded interpreter of your own language.

GYS has built-in lexical and expression analyzer, but during interpretation it calls different user code for executing commands, operators, conversions and value getting. The interpreter is fully runtime - it reads code and interprets it at once. GYS doesn't generate any intermediate code. User doesn't have to use stack to implement his GYS-derived script language.is the scripting engine which helps to create the embedded interpreter of your own language.

The "abstract" GYS interpreter can be called within application to execute the script according to the designed language definition and functionality. The library provides an easy and clear way to define a scipt language interpreter step-by-step: developer can define ... language elements ...

GameMonkey

GameMonkey is a scripting language that is intended for use in game and toolapplications. GameMonkey is however suitable for use in any project requiringsimple scripting support. GameMonkey Script is usually just referred to asGameMonkey and abbreviated to GM (gee-em).
GameMonkey borrows concepts from Lua (www.lua.org), but uses syntax similar toC, making it more accessible to game programmers. GameMonkey also nativelysupports multithreading and the concept of states.

Gamma

was developed to address the frustrations we found trying to build complex control systems using C and C++. We wanted a programming language that would reduce the time and effort required to implement control strategies. Gamma has evolved into a powerful and dynamic language used in mission critical systems all over the world.

GeneralScript

is a lightweight script interpreter(bytecode compiler) that can be used in various applications. GeneralScript was developed as a part of The Gateway isometric role playing game engine but I thought that it would be more useful for everyone if GeneralScript was distributed as an individual project.
As scripts are compiled to bytecode (not machine code), they take very little memory and are quite fast to execute.

Glee

The Glee Programming Language is a new vector oriented interpretive computer programming tool. It is inspired by array oriented languages like APL, J, and K. It attempts to deliver many of the useful and powerful features of those languages for manipulating numeric data. Further, it strives to provide new functionality for consistent and powerful manipulation of character data. It is targeted at applications where languages like PERL, Python, and Java have found secure homes. These are all scalar languages so Glee has something new to bring to the party ... vector processing.

Gont

is a programming language, that consists of largely imperative composition of C-like lexical layer, control structures and speed with ML's typesystem, functions as first class citizens, and safety. Plus possibly few more things, like objects.

Gri

Gri is a language for scientific graphics programming. The word "language" is important: Gri is command-driven, not point/click.
Some users consider Gri similar to LaTeX, since both provide extensive power as a reward for tolerating a learning curve.
Gri can make x-y graphs, contour graphs, and image graphs, in PostScript and (someday) SVG formats. Control is provided over all aspects of drawing, e.g. line widths, colors, and fonts. A TeX-like syntax provides common mathematical symbols.

Gui4Cli

is a simple, freeware, event-driven language which allows you to easily create and control many types of GUIs (user interfaces, windows, dialogs etc) to use as stand alone programs or as interfaces for other programs. It is an easy scripted language with many powerfull commands and capabilities and a simple intuitive structure.

A fifth of the way .. A to E

This list of programming languages was originally on a short-lived weblog called, "Bruce the Goose". Then it appeared down the left-hand side of Code-a-holic.

Over the next few weeks I'll be posting the rest of the data I have on those languages (the bare minimum of name, link, and description.) If anyone's interested in the metacard database or having an XML-ish file with all of the extra details (platform, users' group, date of last activity, etc.), please leave a comment.

Leave a comment too, if you can see anything that needs changing / updating.

E is for ...

elastiC

is a portable high-level object-oriented interpreted language with a C like syntax.

envy

is a 16-bit batch file enhancement tool that adds 38 new batch programming commands to your arsenal.
These new commands include the ability to change environment variables in the parent environment.
The new commands facilitate such things as string manipulation, mathematics, bitwise operations, date/time functions, file operations, random numbers, and others.
Envy will function in MS-DOS and the 16-bit command-processors of Windows 95, Windows 98, and Windows ME.

evlan

Evlan is a pretty simple (though powerful) language, so it shouldn't be hard to get started. To take advantage of the real power features of Evlan, such as predicate-based types and staged programming, you need to use static Evlan. However, static Evlan is not implemented yet, so I guess you're SOL.

execline

is a (non-interactive) scripting language, like sh ; but its syntax is quite different from a traditional shell syntax. The execlineb program is meant to be used as an interpreter for a text file; the other commands are essentially useful inside an execlineb script.

execline is now as powerful as a shell: it features

• conditional loops,
• getopt-style option handling,
• filename globbing, and more.

Meanwhile, its syntax is far more logic and predictable than the shell's syntax, and has no security issues.

EGachine

is an open source (GPL) ECMAScript (JavaScript) game machine/engine using mozilla's JavaScript engine, Spidermonkey. Though the focus is on 2D multi-player (networked) games, EGachine isn't limited to games at all. You can think of EGachine as a programmable OpenGL terminal, which could be used in various ways - for example as presentation tool or movie player similar to Flash, for teaching and learning OpenGL, as special purpose terminal,... . Technically speaking EGachine is a JavaScript interpreter with bindings for subsets of: OpenGL/MESA, SDL, SDL_mixer, SDL_image and ZLib.

ETA

- The design of the ETA programming language follows from the axiom that just because you have to program on a tiny machine, that doesn't mean your programs have to be unreadable.
The designers of less ambitious languages such as COBOL intended that programs written in their languages should be readable to English-speaking managers as well as trained technical staff. ETA goes further by allowing you to write your programs in such a way that they can easily be read by speakers of whatever language you choose.
ETA achieves this lofty goal despite, or perhaps because of, its tiny size. It has very few instructions, and is thus extremely easy to learn. Admittedly, this extraordinary combination of power and simplicity comes at a cost: there is no guarantee that the natural language description in the program text will bear any relation to what the program actually does.
Why the name ETA? There are several reasons. Firstly, it's named after its own instruction set (see below). Secondly it's named after the seventh letter of the Greek alphabet, both to celebrate its use of the base-7 numbering system, and because it comes a little way before iota, indicating how tiny the language is. And thirdly, ETA stands for Estimated Time of Arrival, which is appropriate since ETA programs tend to run rather slowly. Oh, and fourthly, ETA is an anagram of TEA, which is nice to drink.

Easel

is a modeling and simulation programming language intended primarily for research, analysis and depiction of unbounded systems, survivable architectures and emergent algorithms in applications including Internet security, ad hoc communication networks, electric power, and cooperative among autonomous vehicles. Easel is a notation for describing abstract models of anything, a translator, and run-time system for running discrete event simulations from those models

Egg

- In Dijkstra's book "A Discipline of Computer Programming" an anonymous computer language is described. Egg is an interpreter for this language, written in Java using the SableCC package. The name Egg has no significance!

Eleya

- The purpose of this project is to develop a programming language and building a compiler for it. The language is a modern object oriented language with some unique features. The language has some similarities with Pascal but has a different syntax and some interesting extra features, such as:

• classes
  • Nested classes
  • Virtual classes
• Routines:
  • Extended Routines
  • Named Overloading
  • Named parameters
• Types:
  • Extra features of the string type
• Autoloading Units.

Ember

A General Purpose Scripting Language forStand-Alone, Web Base, and Embedded Applications

Empowered Programmer

is an attempt to distill out the essence of what's needed to create a Windows program. EP's deepest purpose in life is simple and direct. This is to create Win32 executables at a basic level ie. close to the machine and OS, and at the same time in an easy way.
So EP is something of an IDE. Nothing else is needed except Win32 documentation (some background in assembly language and hexadecimal notation will be helpful). EP reads a text file written in a particular form and structure and converts it into a Windows .exe file. That's it.
It is not linked to or based on any particular language like C, Basic and so on. It has a mild assembler like syntax but is not a full fledged assembler. As I said before EP's goal is to write Windows programs and as such it supports only a subset of the total assembler instructions available -- only that subset which is needed to write a Windows program.

Emu

Emu (short for Embeddable Utility Language) is a scripting language designed by Aaron Kimball. From the manual: "Emu allows for rapid creation of scripts readily embedded within text files, or as standalone programs."
The Emu language is a high-level language designed to easily embed calculated or extracted data into static files. The language is easy to learn, read, and understand, due to its very simple grammar and syntax - there are few extraneous operators and little "syntactic sugar," but Emu can still perform a variety of tasks, and well.
Emu is a language unto itself, but borrows ideas from Perl, LISP, and (dare I say it), hints of BASIC. (The good hints only. I promise.)

Euphoria

is a simple, flexible, and easy-to-learn programming language. It lets you quickly and easily develop programs for DOS, Windows, Linux and FreeBSD. Euphoria was first released in 1993. Since then Rapid Deployment Software has been steadily improving it with the help of a growing number of enthusiastic users. Although Euphoria provides subscript checking, uninitialized variable checking and numerous other run-time checks, it is extremely fast. People have used it to develop high-speed 32-bit DOS games, 32-bit Windows GUI programs, and Linux X Windows programs.

Ewe

is a programming system that allows you to write applications, using Java, which run exactly the same on desktop systems, on mobile systems, and even in a Web browser as an Applet.
Ewe is comprised of a small footprint, highly optimized Java byte-code interpreter (a Virtual Machine) and a powerful but compact Java class library.
[T]he Ewe VM is not a Java VM since it does not implement a very small number of Java features, nor does it use any of the "standard" Java libraries and API. Ewe has its own set of utility, network, zip, gui and other packages.
Ewe introduces nothing new into the Java language, it simply makes you refrain from using a small number of Java features. Your application will therefore still be a true Java application, but it will be targeted for the Ewe libraries instead of the Java libraries.

D is for ...

Digital Mars D

D is a general purpose systems and applications programming language. It is a higher level language than C++, but retains the ability to write high performance code and interface directly with the operating system API's and with hardware. D is well suited to writing medium to large scale million line programs with teams of developers. D is easy to learn, provides many capabilities to aid the programmer, and is well suited to aggressive compiler optimization technology.

D is not a scripting language, nor an interpreted language. It doesn't come with a VM, a religion, or an overriding philosophy. It's a practical language for practical programmers who need to get the job done quickly, reliably, and leave behind maintainable, easy to understand code.

D is the culmination of decades of experience implementing compilers for many diverse languages, and attempting to construct large projects using those languages. D draws inspiration from those other languages (most especially C++) and tempers it with experience and real world practicality.

DINO

This is COCOM tool set oriented onto the creation of compilers, cross-compilers, interpreters, and other language processors. The distribution also contains interpreter of language DINO as an example of the tool set usage. The tool set is aimed to use on Unixes of different flavors. COCOM also has been ported also into WIN32 environment.

DLGC

A dialog based bash script builder Creating a script with dialog based menus becomes a tedious bit of a job. This script accepts a .dlg file (simple scripting with embedded bash code) and compiles it into a bash script which invokes dialog. It supports multi-level menus

DML

is a simple templating language designed for managing web sites based in static HTML files (no CGI, SSI, etc.). It has been obsoleted by DML2 which has in turn been obsoleted by XSLT.

DML2

is an object-oriented content storage and document formatting framework. Using a fairly simple, object-oriented language and a few templates, generating different types of media from the same source content is made easy. This tool has been obsoleted by XSLT

DPROG

is a domain specific language for specifying dynamic programming algorithms; given a recursive definition of the problem, the compiler generates code for solving the problem using dynamic programming.

Data-Flow Visual Programming Language

is a visual, flow-chart oriented programming environment.

Day-9

(formerly known as NEW) is based mostly on C and its predecessors; it is untyped, powerful and unforgiving. Like C, a program consists of functions, expressions, and statements; unlike C, Day-9 considers both functions and statements to be special cases of expressions. This is Day-9's primary distinction from other medium-level languages, placing it closer to Lisp in its fundamental philosophy. Day-9's philosophy is that every reasonable construct should be legal, and do something reasonable - as long as it has the right number of semicolons.

Dialect

is an advanced, general purpose programming system for Windows 9x/ME/2000/XP and CE that allows developers to write applications with the following features:

• Cross-platform code (Win32 / WinCE).
• Capacity to pre-compile code for rapid execution.
• Integrated development environment with debugger that works on desktop and handheld PCs.
• Support for sockets, serial ports, files, registry access, DLLs, GUI elements, encryption (BlowFish), printing, etc.
• Exception handling mechanisms.
• Regular expressions.
• Generation of stand-alone executables.
• ADO database support.
• The comprehensive help file is also available as a printable (Word) document.

Draak

is a single binary that is able to compile any context free language (like C, Pascal, Java) for any platform. Adding languages or platforms is as simple as adding a single file. Updating a language can be achived with a normal text editor, no recompiling required. Language development is in leap and bounds, and optimizations (unless you take it to the extreme) are simple to use.

DreamMaker

The intelligent programming language is the next generation general-purpose computer programming language based on natural language and human intelligence. It uses standard English vocabularies as programming instructions, English grammars and punctuation for programming syntax. It replaces the arcane and hard to remember symbolic programming instructions, syntax and rules that are used in conventional programming languages such as C/C++, Java, and Visual Basic with plain English sentences. This reduces the complexity in computer programming and helps to make computer programming almost as simple and effortless as interacting with humans. Using English instructions, intelligent programming language minimizes the logical and linguistic mental-translation process that programmers go through when writing programs using conventional programming languages. It enables programmers to efficiently transform programming ideas into robust and powerful computer programs.
DreamMaker tries to mimic the way human brains organize, associate and retrieve information. It not only understands instructions written in a human language like English, it can also intelligently find the best solution out of many possible solutions to a problem. If it needs, it can combine parts of many possible solutions to form the final answer to a problem. The built-in intelligence automatically determines the correct instruction and complete in-between steps for certain instructions. This capability alleviates programmers from the tedious and mundane programming and housekeeping tasks. It greatly reduces the programmers' workload and improves efficiency and productivity. The intelligence of the new programming language makes the programmer's job easier and less stressful and it makes computer programming a more pleasant experience.

DustyScript

The intent of this project is to write a programming language powerful enough to retain a 8/9-yr old's interest but simple enough... that the syntax can be grasped by them

C is for ...

C3

C3 is a xBase language compiler for 16 and 32 bit's. It generates OBJs that may be directly linked to create an executable application for Windows.
On 16 bits mode it links with standard Clipper libraries and on 32 bits mode it links with own C3 ones.
On 32 bits mode there is no limit for the strings size neither for the arrays size.
C3 includes all the Clipper internal functions so it is very easy to port existing Clipper libraries to C3. Objects library has been already ported and it is already part of C3.
The RDD system is identical to Clipper one. Three database drivers are provided: DBF, DBFNTX y DBFCDX.
At the moment C3 offers the xBase compiler and the resources compiler. A Borland linker is required. The recommended version is 1.6.72.0 and it comes included with C++ version 5.0. The GUI is being completely redesigned and you may observe the speed increase at the downloads section.
All C3 users will have access to changes and upgrades through tech support section.

CLIP

is a Clipper/XBase compatible compiler with initial support other xBase dialects. It features support for international languages and character sets. It also features OOP, a multiplatform GUI based on GTK/GTKextra, all SIX/Comix features (including hypertext indexing), SQL and ODBC drivers, a C-API for third-party developers, a few wrappers for popular libraries (such as BZIP, GZIP, GD, Crypto, and Fcgi), a multitasking client and application server based on TCP/IP sockets, object data base utilities, and a functions library.

CMake

is used to control the software compilation process using simple platform and compiler independent configuration files. CMake generates native makefiles and workspaces that can be used in the compiler environment of your choice. CMake is quite sophisticated: it is possible to support complex environments requiring system configuration, pre-processor generation, code generation, and template instantiation.

CSL

- C Scripting Language - is a powerful and easy PROGRAMMING LANGUAGE available for Windows, OS/2 and Unixish systems. CSL follows the C syntax very closely and programmers used to C, C++ and Java will immediately be familiar with it. CSL is used like an interpreter: You write the program with your favorite editor and run it directly like any shell script. More than that, the CSL scripting engine can be integrated into your own applications as a macro language. CSL has 2 programming interfaces: A "C" API for virtually any 32 bit compiler, and C++ class interface for selected compilers.

CafeOBJ

CafeOBJ is a new generation algebraic specification and programming language. As a direct successor of OBJ , it inherits all its features(flexible mix-fix syntax, powerful typing system with sub-types, and sophisticated module composition system featuring various kinds of imports, parameterised modules, views for instantiating the parameters, module expressions, etc.) but it also implements new paradigms such as rewriting logic and hidden algebra , as well as their combination.
CafeOBJ has state-of-art rigorous logical semantics based on institutions. The CafeOBJ cube shows the structure of the various logics underlying the combination of the various paradigms implemented by the language.
The execution of CafeOBJ in compiled mode is based on a rewriting machine that gives CafeOBJ the same efficiency as modern functional programming systems.

Camlot

Camlot is the stand alone Caml Light to C compiler. It then uses a standard C compiler to produce an executable machine code file. The compiler itself is mostly written in Caml Light and the runtime system is written in standard C, hence Camlot is easy to port to almost any 32-bit platform. The performance of the resulting code is quite good, often ten times faster than the bytecode original implementation of Caml Light.
Caml Light implements the Caml language, a functional language from the ML family. Caml is quite close to Standard ML, though not strictly conformant. There are some slight differences in syntax and semantics, and major differences in the module system (these changes were required to support separate compilation).

Casbah

is a free software application framework, which focuses on Web applications, particularly those that are document-centric, distributed, robust, etc. The purpose of Casbah is to simplify and speed the development of Web applications. It aims to do that by allowing developers to focus on the central functionality of their application, instead of the multitude of "plumbing" issues that Web applications face. Casbah provides a set of core services that developers can employ: persistence, distributed computing, multi-language, unified data access model, etc.
Casbah is being developed by Web application developers for Web application developers; we've put things into Casbah that we want to use when we build Web apps. One central design commitment has been to make the so-called "scripting languages" (Perl, Python, TCL, etc.) into "first-class" application tools by surrounding them with a rich infrastructure of services. So we've had to work very hard in designing Casbah to avoid choosing one of the scripting languages and making it the extensibility, scripting mechanism of Casbah. The full version of this multi-language part of Casbah will be forthcoming in a future release of Casbah.

Cheesecake BASIC

is a bytecode-based version of BASIC. Programs can be run from within the compiler, or they can be turned into stand-alone executables (currently for DOS or for the windows console).

Chipmunk BASIC

is an old fashioned Basic interpreter which runs on almost all Macs. Supported features include color graphics, sprites, sound, speech, AppleScript, and even some OOP (object oriented programming) capabilities. Versions are available for System 6.0.7 thru Mac OS X 10.3, for systems from very old Mac 512Ke's up thru the latest Apple iBooks and G4/G5 PowerMacs.

Choon

- The Choon Programming Language - Choon's output is music - you can listen to it. And Choon gets away without having any conventional variable storage by being able to access any note that has been played on its output. One feature of musical performance is that once you have played a note then that's it, it's gone, you can't change it. And it's the same in Choon. Every value is a musical note, and every time a value is encountered in a Choon program it is played immediately on the output.

CocoaBasic

Did you ever

• want to write programs that look and operate like other MacOS X applications?
• hesitate to get hands on the 250 MBytes of the Project Builder and learn Objective C?
• have the experience of simplified object oriented BASIC programming?

Then, CocoaBasic seems to be the right decision.
CocoaBasic is an Interactive software Development Environment for using the Cocoa Framework in an object oriented Basic Dialect.

CodeWorker

is a versatile Open Source (GNU Lesser General Public License) parsing tool and a source code generator devoted to generative programming. Generative programming is a software engineering approach interested in automating the production of reusable, tailor-made, adaptable and reliable IT systems. In layman's terms, CodeWorker lets you generate code by parsing existing languages, or by creating and parsing your own language. Once a language file has been parsed, CodeWorker provides several techniques for generating code. The tool's scripting language drives the parsing and source code generation process. The scripting language syntax is derived from the C family of languages, making it familiar to most programmers. The template syntax is like like JSP, ASP, or Velocity. It has variations for parsing, code generation, or functional programming, giving the developer a number of options for organizing CodeWorker projects.

Confluence

is a powerful logic design language that combines the dataflow and component-based methodologies of HDL with the expressiveness of modern functional programming. With clean and elegant semantics, Confluence has flexibility far beyond the reach of Verilog or VHDL, resulting in smaller, more compact source code that is quicker to produce, easier to manage, and faster to verify.

Crow

was a language I designed as my final project in college. It was a superset of Icon with signalling features. It was pretty cool, in my opinion. But it wasn't well understood, even by me, at the time. My professor wasn't interested in it at all. Oh well.

Cyclone

is a programming language based on C that is safe , meaning that it rules out programs that have buffer overflows, dangling pointers, format string attacks, and so on. High-level, type-safe languages, such as Java, Scheme, or ML also provide safety, but they don't give the same control over data representations and memory management that C does (witness the fact that the run-time systems for these languages are usually written in C.) Furthermore, porting legacy C code to these languages or interfacing with legacy C libraries is a difficult and error-prone process. The goal of Cyclone is to give programmers the same low-level control and performance of C without sacrificing safety, and to make it easy to port or interface with legacy C code.

ciao

- The Ciao Prolog System - is a public domain, next generation multi-paradigm programming environment with a unique set of features ...

claire

is a high-level, portable, functional and object-oriented language with advanced rule processing capabilities. It is intended to allow the programmer to express complex algorithms with fewer lines and in an elegant and readable manner.

• To provide a high degree of expressivity, claire uses
• a rich type system including type intervals and second-order types (with static/dynamic typing),
• parametric classes and methods,
• propagation rules based on events,
• dynamic versioning that supports easy exploration of search spaces.
• To achieve its goal of readability, claire uses
• set-based programming with an intuitive syntax,
• simple-minded object-oriented programming,
• truly polymorphic and parametric functional programming,
• an entity-relation approach with explicit relations, inversesand unknown values.

B is for ...

BCPL

This distribution of BCPL is free of charge to individuals for privateuse and to academic institutions, but please, if you install thesystem send me an e-mail message so I can keep arecord of who is interested in it. It is available via my Home Page(http://www.cl.cam.ac.uk/users/mr).
It provides a machine independent interpretive version of BCPL. Theinterpreter in implemented in C, but for many architectures it alsohas a version implemented in assembly language which greatly improvedthe performance.
This distribution contains versions of the system for Linux, DEC Alphamachines, Mips R2000/3000 machines, Sun4s, Sun/SPARCs and386/486/Pentium machines under MSDOS, Windows 95/98/NT/2000, Windows CE2.0(for the HP 620LX), MAC or OS/2. The implementations for the MAC andOS/2 have not been tested recently and are out of date. The simplestinstallation is for Linux machines. Installation on other machines isdescribed later.

BETA

is a modern language in the Simula tradition. The resulting language is smaller than Simula in spite of being considerably more expressive. BETA is a strongly typed language like Simula, Eiffel and C++, with most type checking being carried out at compile-time. It is well known that it is not possible to obtain all type checking at compile time without sacrificing the expressiveness of the language. BETA has optimum balance between compile-time type checking and run-time type checking.

BLISS

IGNORANCE --- THE INCOMPLETE BLISS COMPILER
This directory contains partial code for a BLISS compiler written in C, Yacc,and Lex. It was written by The Unknown Scandinavian, who lost interest init and asked me to file his name off the sources.
It would be nice to turn this into a BLISS-to-C translator. The lexical analyzer is working. The parser is incomplete. There is no back end. Thebest news is that the package includes a very detailed and completedescription of BLISS intended as a specification for the compiler.

BLOC

is a programming language, a BASIC programming language with some more features that not implemented in similar compilers, this is why call it Basic Like Object Compiler. BLOC is based on translating your sources to Pascal code and compiling it into binary executables. So it's compiler, but for today it's translator also, because translating for BLOC is main part of application deployment before compilation procedures.
It is multiplatform, almost completely compatible in terms of the graphical interface. GUI part currently under development, but as for underlying language it is compatible between platforms. Today BLOC is available for Windows and Linux and in near future we planning support for QNX and Palm OS. You can use BLOC to create GUI, CONSOLE applications and CGI applications for your preferred web server.
BLOC uses Free Pascal compiler for making binary executables and dynamic link libraries. This is why BLOC does not require an interpreter. BLOC application is completely stand-alone. BLOC was originally created to provide a free implementation of a BASIC programming language for creating webware applications, so features like working with XML, SQL, Sockets and etc will be high priority tasks for BLOC.

BOIL

Brunnis Own Interpreter Language - is a C-like language that was developed by netEstate under Linux for special purposes. We are releasing it free of charges under the GPL because it has some special features that you will miss in other similar languages ...

BPL

is an enhanced Win32 batch interpreter that runs portably on Win95/Win98/NT/2000. BPL supports a superset of commands commonly found in batch interpreters.

BRL

- the Beautiful Report Language

• Beautiful: It is easy to write BRL code that is understandable and maintainable, appealing to a programmer's sense of aesthetics.
• Report: BRL is particularly suitable for constructing output that is a mix of static and dynamic content, e.g. web pages, e-mail messages. Its greatest strength is constructing output from SQL databases.
• Language: The full power of a general-purpose programming language is there when needed. Simple examples are trivial uses of the language, but look more like templates than programming. The template system and programming language are more tightly integrated in BRL than in any other system.

BRiX

is a new operating system that redefines how operating systems should be designed. Like conventional operating systems, it will provide features such as SMP, preemptive multi-threading, virtual memory, a secure multi-user environment and an easy to use graphical interface.Crush is the language used by BRiX to handle system security and package management. All other compiled languages, used in BRiX, must generate Crush code instead of compiling executable binaries. Interpreted languages do not produce binaries and do not need to compile through Crush. Crush is a safe-language and thus produces code that can do no wrong. It compiles in runtime safety checks, when needed, to catch faulty code and requires special authorization before compiling low-level features, such as assembly code, that shouldn't be used by normal users. Abstract macros can be used to replace imperative blocks of code that would require numerous safety checks. And because all code must be compiled locally it is virtually impossible for viruses and other malicious code to be executed on a BRiX system. Crush is a meta-language and has no primitive types or constructs so it must be powerful enough to write these from scratch. The language will include a rich set of types and constructs but it is possible to design another language around the raw core. Constructs are added to the language with special macro functions that are executed at compile-time and have access to the core's environment.

BScript

is a (yet another) BASIC interpreter. It is free software and open-sourced, licensed under the terms of the GNU General Public License version 2 or later. You can use BScript to teach BASIC to your students, write understandable shell scripts (good bye, spaghetti code!), automate simple tasks, or even write a game!

BUSH

(Business Shell) is a powerful Linux/UNIX shell for designing secure, reliable shell scripts that can be later compiled as a fast executable programs. It can also be used an an interactive login shell or to generate Java Virtual Machine applications. BUSH is a robust and readable alternative to BASH, CSH, and (to a certain extent) Python and PERL.

Bas

Bas is an interpreter for the classic dialect of the programming language BASIC. It is pretty compatible to typical BASIC interpreters of the 1980s, unlike some other UNIX BASIC interpreters, that implement a different syntax, breaking compatibility to existing programs. Bas offers many ANSI BASIC statements for structured programming, such as procedures, local variables and various loop types. Further there are matrix operations, automatic LIST indentation and many statements and functions found in specific classic dialects. Line numbers are not required.

The interpreter tokenises the source and resolves references to variables and jump targets before running the program. This compilation pass increases efficiency and catches syntax errors, type errors and references to variables that are never initialised. Bas is written in ANSI C for UNIX systems.

BeeBasic

is an embeddable basic interpreter that can greatly extend your application's capabilities. It is a C++ library that adds object-oriented basic script to your application. With BeeBasic you can call your application's functions and manipulate your application's objects from script.

Biferno

is a new generation, Cross Platform Web Scripting Language that allows developers the rapid implementation of dynamic Web applications and of Web sites that offer a high degree of user interactivity.
Biferno is a Web server add-on module that allows dynamic generation of HTML pages. The result of the processing of the Biferno code by the server determines the page content. A Biferno script is therefore a server-side script, i.e. the Web server is tasked with code processing.
Biferno is currently implemented only as an interpreted language, but Tabasoft is developing a compiler that will be soon released.
Biferno is also a "HTML-embedded" language. Scripts can be written in pure Biferno language, but can also contain HTML code segments between Biferno code blocks.

Bla

abstract: We investigate an (unpure) functional language whose concept of environment is not implicit as in traditional languages, but made available explicitly as a first class value. This results in a semantics for environments that is best known from the object oriented paradigm, and gives us a united function/class concept in a very orthogonal way. We also look at the language as a real-world general purpose language, considering semantics (of type-inference, for example), implementation issues, and practical experience in using the compiler.

Bluestone

Bluestone 32-bit compiler version 1.0 is a little project written by Bluestone, to provide programmers with an alternative language to making games. This is a only a subset of the final version and was released to get peoples reaction. Its is totally free and no credit need to mentiond to me, but if it would be nice to mention Tran and Matt Pritchard. There are many bugs in this program so wait for the final version.

Bob

dynamic object-oriented language with syntax similar to C/C++, Java, and JavaScript. It supports a prototype-based single-inheritance object model where there are no separate classes or instances. Every Bob object inherits behavior from another object and any Bob object can serve as the prototype for another Bob object. The prototype model makes it easy to create singleton objects, which are quite common in user interfaces. It is also a model that is familiar to JavaScript programmers.

Borneo

changes and extends Java so that all IEEE 754 features can be expressed and so that new numeric types can be easily created. Borneo allows either better hardware use than Java or (nearly) exact reproducibility while in all cases being predictable.
Unfortunately, it seems Borneo will remain a language design without an implementation.

BullFrog

- The Language with No Conditional Jumps
All jumps are unconditional. That's right - there are no if statements, no while loops, no for loops, nothing like that. All expressions are in FORTH expression syntax. (yet another Forthoid language, sort of a weird cross between Forth and assembly language) If you want to execute code conditionally, you have to do it like this:

    condition ;0 for false, 1 for true
    (label1 label2 -) * label2 +
    JUMP
    label1:
    ;code to execute conditionally goes here
    label2:

blassic

Blassic is a classic Basic interpreter. The line numbers are mandatory, and it has PEEK & POKE. The main goal is to execute programs written in old interpreters, even those that use peculiar control flow constructs or automodifiable code. However, it can be used as a scripting language, and has some not-so-classic instructions. It has graphics modes that are compatible with some classic systems and user defined.

brain

is a high-level, purely object-oriented, prototype based scripting language, mostly similar to the Self language.

burapha

- The Burapha Compiler Kit - contains a compiler, an assembler, a GUI byte-code VM interpreter all written in tcl/tk, and documentation on their design and implementation. The interpreter GUI includes English and Thai modes. I really need somebody to translate stuff from English into Thai so that the documentation and interface for the Thai version can stay up to date. I know you are out there somewhere....

bx

In 1990 Tom Markson and I developed a compiler for a new language we had designed, called 'bx'. The main features were:

• objects (called "boxes" in bx)
• interfaces (called "concepts" in bx)
• parameterized types
• no inheritance
• operator overloading
• generators
• functions which could appear on the left side of an assignment statement
• static instantiation of all type parameterizations for efficiency
• compilation to C

A is for ...

ABC

ABC is an interactive programming language and environment for personal computing, originally intended as a good replacement for BASIC. It was designed by first doing a task analysis of the programming task.

ABC is easy to learn (an hour or so for someone who has already programmed), and yet easy to use. Originally intended as a language for beginners, it has evolved into a powerful tool for beginnersand experts alike.

Here is an example function words to collect the set of all words in a document:

   HOW TO RETURN words document:
      PUT {} IN collection
      FOR line IN document:
         FOR word IN split line:
            IF word not.in collection:
               INSERT word IN collection
      RETURN collection

Some features of the language:

• a powerful collection of only 5 data types that can easily be combined
• strong typing, yet without declarations
• no limitations (such as max int), apart from sheer exhaustion of memory
• refinements to support top-down programming
• nesting by indentation
• programs typically one fourth or one fifth the size of the equivalent Pascal or C.

Some features of the environment:

• no need for files: procedures and functions and global variables remain after logging out
• one consistent face is shown to the user at all times, whetherexecuting commands, editing, or entering input to a program
• generalized undo mechanism.

ABCL

The tenet of our ABCL research project is to exploit both parallelism and object orientation. Parallelism is ubiquitous in our problem domains; parallelism is not only the source of computational power, but also promotes structural simplicity/naturalness in design and algorithm. Object-orientation accompanying parallelism, enhances system modularity, flexibility, and safety. Such an approach, called object-oriented concurrency, is summarized as follows:
* the software or algorithm to be designed/constructed is represented as a collection of concurrently executable (concurrent) objects, and
* the interaction among the system components is represented solely as message transmissions among such objects.
A concurrent object models the functions and properties of an entity appearing in a problem domain. It is an encapsulated (program) module which contain data and the associated procedures to operate on the data, and also perform message passing. Upon receiving a message, it becomes active and executes a procedure specified by the message. Message transmission may take place concurrently among objects, thus enabling objects to be active in parallel. The basic mode of message passing in our approach is asynchronous in the sense that an object can send a message whenever it wants to, irrespective of the mode of the receiver of the message. This expands the degree of parallelism allowed in a system. We also assume that an object is able to create new objects dynamically. The capability of dynamic object creation is indispensable in modeling and representing complex, open systems naturally. We believe that the asynchrony and this dynamicity are fundamental in our approach. We developed a parallel computation model ABCM/1 (An object-Based Concurrent computation Model 1) and its associated description language ABCL/1 (An object-Based Concurrent Language 1). ABCM/1 is based on our notion of "objects", while ABCL/1 serves as a programming language in which systems and algorithms are written based on objects defined in ABCM/1. From ABCM/1 and ABCL/1, our research project has stemmed mainly towards three directions: theory, implementation/environment, and application. In each direction, there are a number of research topics that have been identified and investigated.

ACC

(pronounced by naming the letters A, C and C) is a near-C compiler for the IBMPC line of computers for MSDOS programs. The compiler and compiled programs will run on any 386 or above PC running MSDOS. Included with the compiler are a 386 assembler and a linker for combining multiple object files. There are also two libraries, which are a protected mode dos extender (Based on Thomas Pytel's (aka Tran's) PMODE30B + PMODE307 dos extenders), and a library of useful functions callable by C programs. Pointers are 4 bytes, and can access all available memory. You can allocate blocks as large as you want (megabytes) as long as there is memory available.
The compiler, assembler and linker are all very small and fast. The code generated is adequate for most programming needs, but time critical stuff should be written in assembler. The compiler supports easy inline asm with the #asm, #endasm directives. The assembler syntax is very similiar to TASM's.

AKL

(AGENTS Kernel Language) is a concurrent constraint programming language developed at the Swedish Institute of Computer Science (SICS). In AKL, computation is performed by agents interacting through stores of constraints. This notion accomodates multiple programming paradigms; in appropriate contexts, AKL agents may be thought of as processes, objects, functions, relations, or constraints.
AGENTS is a system for programming in AKL. It provides a complete implementation of AKL with records, finite domain constraints (over integers), and port-based communication, a novelty of AKL. It also provides assorted built-in agents, libraries, and other support.

ALF

is a language which combines functional and logic programming techniques. The foundation of ALF is Horn clause logic with equality which consists of predicates and Horn clauses for logic programming, and functions and equations for functional programming. Since ALF is a genuine integration of both programming paradigms, any functional expression can be used in a goal literal and arbitrary predicates can occur in conditions of equations. The operational semantics of ALF is based on the resolution rule to solve literals and narrowing to evaluate functional expressions. In order to reduce the number of possible narrowing steps, a leftmost-innermost basic narrowing strategy is used which can be efficiently implemented. Furthermore, terms are simplified by rewriting before a narrowing step is applied and also equations are rejected if the two sides have different constructors at the top. Rewriting and rejection can result in a large reduction of the search tree. Therefore this operational semantics is more efficient than Prolog's resolution strategy.

AMC

AMC is a a language translator that gets its translation rules from aprogramming language called CGL (code generation language). AMC generatesoutput by running a back end program (usually a C compiler or assembler) ona text file that it creates during parsing of the source code.
In addition, AMC also adds a module structure and build facility that is quite simple to understand yet works well for large projects.
AMC was developed on an HP 710 running HP-UX using the GCC compiler.However, the majority of the code for AMC conforms to the ANSI C89 standard.There is a small portion of code that interfaces with the operating systemand is non-portable, but this code is easily replaced to adapt AMC to a newoperating system.

APLX

APL is a unique, general-purpose high level programming language used in application areas such as financial planning, market research, statistics, management information and for all types of scientific and engineering work. APLX is an advanced, second generation implementation of the APL language, closely based on IBM's APL2, but with a number of important enhancements (see the APLX Language Specification).

ATOM

Atom is a programmable, register based virtual machine for Win32 computers. The program is a text-base console application. The VM can be programmed using a neo-assembler language called Atom Assembler. This document discusses the VM and explains each opcode in Atom Assembler.

Agora

is a reflective prototype-based object-oriented programming language that is entirely (and solely!) based on message passing. Message passing is considered as one of the fundamental characteristics of object-oriented programming languages. It lies at the heart of late-binding polymorphism which is the key feature that makes incremental modification of programs possible. However, prototype-based languages often go beyond message passing. Deep down in their implementation, many things such as delegation, encapsulation, cloning and object concatenation can be found as explicit operations on objects. By making such languages reflective, these implementation operators also become visible to the programmer. As such, the programmer can easily bypass the message passing paradigm just by 'going meta'. Also, very often, these operators are an explicit feature in the language, even when reflection is not a language feature. We claim that these explicit operators on objects is the source of encapsulation problems, over-flexibility and the reason why it is so difficult to make abstractions in (reflective) prototype-based languages. We therefore designed Agora as a prototype-based object-oriented programming language whose only operation on objects is message passing. Agora shows that even within these limits, it is possible to build a full-fledged object-oriented language that features inheritance, cloning and reflective operators. The idea is that an object is fully encapsulated and can only be subject to message passing. But seen from the inside of the object, the object knows all about it's own structures. It is therefore perfectly capable of cloning and extending itself. This is accomplished by special methods we call cloning methods and mixin-methods.

Alambik

is based on MCNL, a breakthrough language which is to interactive audiovisual publishing what HTML is to interactive press publishing.

Similar in use to HTML, MCNL combines a complete set of text-based programming instructions with text-based audiovisual commands (video, audio, 2D, 3D, vectorial, etc.). These two conceptual worlds, once distinct, are united synergistically under Alambik within a simple, uniform programming environment, for scripting real-time audiovisual creations.

Alambik is fully complementary to HTML. Its audiovisual, interactive multicontent rounds out HTML content, enhancing the overall end-user experience in much the same way that radio and television round out - without replacing - the traditional press.

Afnix

is a multi-threaded functional programming language with dynamic symbol bindings that support the object oriented paradigm. Afnix features a state of the art runtime engine that supports both 32 and 64 bits platforms. Afnix comes with a rich set of libraries that are designed to be platform independent. Afnix is a free software. A flexible license has been designed for both individuals and corporations. Everybody is encouraged to use, distribute and/or modify the Afnix engine for any purpose.

Afnix is an interpreted language. When used interactively, commands are entered on the command line and executed when a complete and valid syntactic object has been constructed. Alternatively, the interpreter can execute a source file. Afnix does not have a garbage collector. Afnix operates with a lazy, scope based, object destruction mechanism. Each time an object is no longer visible, it is destroyed automatically.

Algol68G

Algol 68 Genie - is a fairly fully featured Algol 68 implementation. Algol68G's front-end parses an entire Algol 68 source program. If parsing is successful, the syntax tree (that serves as an intermediate program representation) is interpreted by Algol68G's back-end.

Alma

ALMA-Towards an Imperative Constraint Programming Language
Alma project aims at a realization of a strongly typed constraint programming language that combines the advantages of logic and imperative programming.
At this stage the first layer, Alma-0, is available. Alma-0 extends a subset of Modula-2 by features that facilitate writing programs that involve search.

Alvyn

is an Open Source free software multiplatform BASIC interpreter written entirely in C++ , developed with aim to be 100% compatible with AMOS Professional (Amiga), to allow game developing on Unix system. Alvyn uses SDL library (see www.libsdl.org) for music and graphic framework

AutoIt v3

is an opensource BASIC-like scripting language designed for automating the Windows GUI. It uses a combination of simulated keystrokes, mouse movement and window/control manipulation in order to automate tasks in a way not possible or reliable with other languages (e.g. VBScript and SendKeys).

AutoIt was initially designed for PC "roll out" situations to configure thousands of PCs, but with the arrival of v3 it is also well suited to performing home automation and the scripting of repetitive tasks.