Friday, March 03, 2006

Extras 2006-03-03

is an open-source implementation of the AWK programming language.

Awka is not an interpreter dtke Gawk, Mawk or Nawk, but instead it converts the program to ANSI-C, then compiles this using gcc or a native C compiler to create a binary executable. This means you must have an ANSI C compiler present on your system for Awka to work.

is an high-level dynamicly typed programming language. It can be used as an embedded scripting language. It has been designed to provide a common runtime for several different languages. Learning and using Neko is very easy. You can easily extend the language with C libraries. You can also write generators from your own language to Neko and then use the Neko Runtime to compile, run, and access existing libraries.

If you need to add a scripting language to your application, Neko provides one of the best tradeoff between simplicity, extensibility and speed.

Neko is also a good way for language designers to focus on design and reuse a fast and well-designed runtime, as well as existing libraries for accessing filesystem, network, databases, xml...

BlackBox Component Builder
developed by Oberon microsystems, is the component-based development environment for the programming language "Component Pascal".

Due to its stability, performance and simplicity, BlackBox is perfectly suited for science and engineering applications.

Thanks to modest hardware requirements, BlackBox can also be used in countries with limited IT infrastructure, for development, education and research.

The COW programming language was designed with the bovine in mind. Given that cows have somewhat limited vocabulary skills, it seemed natural to incorporate only the words they know into the language. As a result, all instructions are some variation on "moo" which just so happens to be the only word they really understand.

Any other word or symbol that isn't an instruction is ignored entirely. So, spaces can be used or not. Newlines can be used or not. You get the idea. It makes commenting COW programs rather easy as long as you don't use any words that have an instruction embedded in it. All instructions are case-sensitive.

The ideas of neural networks, fuzzy logic, and genetic algorithms are included in a mid-level computer language, FUNGAL (FUzzy logic/Neural network/Genetic Algorithm Language). This language operates on a plug-and-play network architecture based on inexpensive microprocessors, and provides for completely self-contained autonomous control of a serpentine robot. Three robots are built to exhibit individual autonomous control, semiautonomous teleoperation, and co-operation. A comparison of FUNGAL to other artificial intelligence systems is included. Finally, applications in space exploration and commercialization, deep-sea missions, nanotechnology, and np-complete software problems are discussed.

In 2000 a.d. we started a project called "DiNGS Game Basic" DiNGS is an easy to use 2D programming language. We made a lot of progress since then, and perfected all areas, where improvements were possible. Our language grew up, and is now a professional 2d game programming kit.

Our next great accomplishment is GLBasic, which is a complete 2d/3d/networkable cross platform programming language. If you are searching for a easy to learn, fast to write, and flexible language for programming games: GLBasic is what you need.

If you don't want to learn real programming, these programs aren't for you.

If you want to compete against professional game programming companies, learn C/C++ and found your own company with at least 5 employees, you selected carefully. Good luck.

If, however, you wish to create games that have high quality on your own with little time to waste creating a game engine, a 3D framework or network components, your choice will be GLBasic.

- Meta Language

METAL is a 100% free extended BASIC language metacompiler for Mac.

The ultimate goals of METAL are to bring back the spirit of 1980s programming and provide both beginners and advanced developers with a way to quickly convey their ideas and focus on creativity!

METAL is made by Marin Saric

Mobile BASIC
Mobile BASIC 2.1 allows your PC to create programs for your Java enabled Mobile Phone using our easy to learn version of the BASIC programming language. The language features integer, long, floating point and string variables, logarithm and trigonometry functions, network communications and graphics facilities. The development environment also includes integrated Map, Tile and Image editors.

Mobile BASIC 2.1 can create programs for Nokia, Sony-Ericsson, Siemens, Sharp, Motorola and Other Mobile Phones supporting Java.

Palm Basic
Palm Basic is a utility written for the Palm series of handheld devices. It is designed to allow you to write programs on your Palm for your Palm. The language is designed to be simple to use, yet sufficiently powerful to allow the construction of genuinely useful programs.

Palm Basic consists of a program management screen, similar to memo pad. This allows you to organise your programs by category. From here, you can edit and run your programs, or you can go into console mode. Console mode allows you to execute single lines of BASIC, or to run your programs by name.

Palm Basic supports integer, floating point, and string variables, as well as single and multi-dimensional arrays. It supports the common structures found in BASICs i.e. for - next loops, do - loop, if - else - then (either on a single line or over multiple lines), goto and gosub. It contains built-in procedures for formatted printing and inputing, basic graphic operations, as well as a full set of floating point math functions.

Parrot is a virtual machine designed to efficiently compile and execute bytecode for interpreted languages. Parrot will be the target for the final Perl 6 compiler, and is already usable as a backend for Pugs, as well as variety of other languages.

PocketC Architect
PocketC Architect combines some of the best features of classic PocketC and OrbForms Designer. At its core, PocketC Architect is the advanced OrbC compiler rebuilt to run on either the desktop or the Palm itself, and enhanced to provide compatibility with classic PocketC source code. We've started this new product at v4, because it uses the same compiler and runtime as OrbForms Designer v4 will. See the new PocketC Architect section for full features and download.

stands for Popular Assembler. It is an assembler (i.e. an assembly language compiler) designed to meet the needs of as many assembly language programmers out there as possible... This is NO easy mission, I know...

ToonTalk 2
ToonTalk is a completely new kind of software -- both a state-of-the-art programming language and a video game. Children create programs by performing actions in an animated world.

Computer programming can be a creative, empowering, and rewarding activity. Programs can be constructed for an incredible variety of purposes -- games, music, math, animation, simulation, science, language, robotics, education. The process of building programs entails a rich set of problem-solving skills involving analysis and design. And computer programming is a worthy subject to learn on its own merits.

But programming can be hard -- hard to learn and hard to do. Programmers usually have to learn a formal textual programming language full of difficult abstract concepts like variables, procedures, flow of control, data structures, modularity, and recursion. Some children do learn languages like Logo or Basic, especially when taught by a gifted and dedicated teacher, but most find it frustrating and boring.

ToonTalk is different. It is not only easy to learn, but fun too. It borrows heavily from video games -- appealing graphics and animation, a virtual world to explore, animated characters to interact with and get help from. Children can learn ToonTalk by playing the tutorial game, by viewing demos and tours, or by exploring with or without the help of a Martian animated coach and guide.

But ToonTalk isn't just a video game for teaching programming -- the very act of building, running, and debugging programs is like playing an adventure game. In ToonTalk, it is not only fun to play with the resulting creation, it is fun to build it.

Whirl was designed with the following state-of-the-art features in mind:

  • Inheritence

  • Simplicity

  • Ease of use

  • XML

  • Maintainability

  • Polymorphism

  • Flexibility

  • Power

  • Subtraction

  • Grilled Chicken

Unfortunately, none of those things made it into the final product.

The Whirl programming language has only two instructions: 0 and 1. While the Whirl Team was tempted to build a compiler that converted text source files of 0s and 1s into very small binary files with a sequence of 0/1 bits, the idea was thwarted at the last minute by a sudden attack of laziness. Maybe it'll happen later on when Whirl becomes adopted by the enterprise market to replace the aging Java platform.

In the world of Whirl, there are two instructions and two rings of 12 things to do on each. The instructions manipulate the rings and activate commands on the rings. The rings can also store some data within them. The rings always maintain their position and state, so nothing really resets the rings back to their default position. A Whirl programmer must always keep track of where the rings are positioned so as to not get a headache. Unfortunately, trying to track the rings' position after about 10 instructions often results in a sudden stoppage of programming due to the programmer's brain getting so dizzy it forgets how to breathe. WARNING: Programming Whirl may be hazardous to your sanity!

The Whirl environment generously gives the programmer the following tools:

  • An "infinite" supply of data memory

  • An ability to change the program's instruction position

  • One ring of 12 Control/Logic/IO operations

  • One data storage slot for the operations ring

  • One ring of 12 Math functions

  • One data storage slot for the math ring

  • Two easy-to-remember instructions

The FermaT Transformation System is a powerful industrial-strength program transformation system based on the WSL language.

Friday, February 24, 2006

Right, that's the lot then

At least, that's all that was in the original MetaCard database. There are a few back on Codeaholic that still need to be added. And there's likely to be some errors in the links.

[big sigh of relief]

Z is for ...

Zen is a full featured BASIC interpreter for the Linux operating system running on the PC. Ensure that the zen executable is placed on your path (suggest /usr/bin) and is 'chmod a+x zen'. The zenerror.inf file contains a full list of the zen error messages. This file can either be placed in '/var/zen' (which you will need to create) or in the current working directory. You may alter the text of the error messages, to another langauge for example. A small test application is included called test.zen.

is a programming language named after the philosopher Zeno of Elea. The Zeno language is an easy to learn, user friendly, high level, computer programming language. It is more like natural English than most other computer languages and this makes a Zeno program both easy to write and easy to understand. No prior programming experience is required. Zeno is generic in the sense that it contains most of the essential elements used in other languages. If you already know how to program in another language, this one should be easy for you to master.

The Zeno Interpreter was designed for use in the MS Windows 95 and later operating systems. The interpreter, with its built-in debugging tools, will allow you to learn good programming techniques. Included with the interpreter is an editor and an on-line language reference program. Together, these create an environment for you to learn to program in Zeno.

is an object oriented, prototype-based, persistent programming system. The employment of Zero (or any ot its parts) is completely free, and the author does not retain any copyright over any program created with it.

Y is for ...

Y is a stack-oriented FORTH-type programming language derived from Wouter van Oortmerssen's "FALSE".

Like FALSE, Y is cryptic to the extreme. (But it is much more powerful. Virtually all of the example programs in "Kernighan & Ritchie - Programming in C" can be done in Y in a fraction of time and code. :-) )

This stuff is provided as-is, I won't take any responsibility for damaged software, hardware, or brains. Since I'm still developing (well, something like that...), this is a very early beta version. Y looks stable and the small Y programs I tested worked fine, but this doesn't have to mean anything.

Y is what you get when you cross a programmable pocket calculator with a programming language like C. For some, Y is merely a toy. (But a very powerful one.) For others, it's just another cryptic unixlike command which probably can save you much time in special situations.

There are many good programming languages for doing large projects, but what do you use if you want a quick solution for those small but nasty everyday's problems which can't be managed with common commands? One day, I had recieved an ascii data file which must have gone through some noise-producing 7/8-Bit-gate. About twenty per cent of the characters had their highest bit set, so the text was totally corrupted. With Y, it took me less than twenty keystrokes to solve the problem by writing a binary filter. Here it is:

implements the most common and simple elements of the basic language It comes with goto/gosub, with various loops, with user defined subroutines and Libraries. Yabasic does monochrome line graphics and printing. Yabasic runs under Unix and Windows it is small (around 200KB) and free.

does the same job for Tcl that yacc or bison do for C. You can specify a grammar in a form similar to the Backus-Naur Form (BNF), and define scripts that are executed whenever a rule is matched.

After all rules have been added, Yeti dumps code for a [incr Tcl] class that implements the parser. This parser uses a deterministic state machine computed from the rules. This has the advantage of using only linear runtime and memory for parsing, but the disadvantage that it is not possible to update the parser after parsing has started. It is common usage to generate a parser once at package installation time, and to store the parser in a file, from where it is then sourced.

Parsers need a scanner to their job. The purpose of a scanner is to read tokens (terminals) from an input source. A scanner generator called Ylex is included in the Yeti package; after adding rules, it also dumps code for a scanner class.

Yeti is written in Tcl. It requires Tcl 8.x, [incr Tcl] 3.x. The parser generator also requires the struct module from tcllib; this module is not needed to run generated scanners and parsers.

is an interpreted programming language, designed for postprocessing or steering large scientific simulation codes. Smaller scientific simulations or calculations, such as the flow past an airfoil or the motion of a drumhead, can be written as standalone yorick programs. The language features a compact syntax for many common array operations, so it processes large arrays of numbers very efficiently. Unlike most interpreters, which are several hundred times slower than compiled code for number crunching, yorick can approach to within a factor of four or five of compiled speed for many common tasks. Superficially, yorick code resembles C code, but yorick variables are never explicitly declared and have a dynamic scoping similar to many Lisp dialects. The yorick language is designed to be typed interactively at a keyboard, as well as stored in files for later use. Yorick includes an interactive graphics package, and a binary file package capable of translating to and from the raw numeric formats of all modern computers.

X is for ...

X Language
is a new multi-syntax programming including a portable set of APIs to create console or graphical applications runnable on many platforms (UNIX/X11, Win32, ...). X Language comes with an interpreter, a compiler and a debugger.

is a Basic interpreter with full X graphic capability. The syntax is most similar to the old GFA-Basic ATARI-ST implementation. Old GFA-Basic programs should run with only few changes. The actual implementation runs on UNIX workstations (DEC-alpha, HP-UX, FreeBSD, Mac-OSX, CygWin) and Linux-PCs (SuSE, Rethat, Mandrake ...) with the X Window system. The WINDOWS 95/98/NT-Version is still incomplete.

provides technical guidance and source code so that you can readily design and implement an interpreter according to your own requirements. You may need, for example, to create a special interpreter for a domain specific language, script language, or other "little language".

XIDEK can save you weeks or months of work. It gives you parsers, support modules, explanations, examples, organization and a framework upon which you can build.

The XPL programming language is a derivative of PL/I designed for compiler writing. XPL was first announced at the 1968 FJCC in San Francisco, CA.

XPL is the name of both the programming language and the compiler generator system (or TWS: translator writing system) based on the language.

is a Logic Programming and Deductive Database system for Unix and Windows. It is being developed at the Computer Science Department of the Stony Brook University, in collaboration with Katholieke Universiteit Leuven, Universidade Nova de Lisboa, Uppsala Universitet and XSB, Inc.

is a fast and powerfull command-line XML editor. It may be used to query and modify XML documents. XSH may be used either interactivelly or for off-line processing (like bash). XPath expressions are used to select parts of XML document to be processed. Both system shell and perl are accessible from XSH in a very natural way. XSH itself is written in Perl and uses XML::LibXML bindings of gnome-xml2 library in the background level.

W is for ...

is a Basic interpreter that is:
  • Free
  • Open Source (LGPL)
  • Cross-platform (currently Windows and Linux)
wxBasic can create stand-alone executables by binding together source code with the interpreter. wxBasic is written primarily in C, with some C++ linking it to the wxWidgets library. wxWidgets supplies the cross-platform features. wxBasic runs on Windows using native controls, and Linux using the GTK Library. A Macintosh port is being actively investigated.

This is the visual compiler for programing games in 2d (strategic, ation, etc.) for windows, linux, unix and mac os! this very easy languaje, very similar to Div Games Studio. You can do exe files, and the instalation pack. (Spanish language)

is a rapid prototyping environment for creating and delivering GUI-based applications. It fills the same niche as TCL/TK, and Python, while employing more proven (and stable) underlying technologies. WINTERP uses a small, fast, object-oriented mini-Lisp interpreter based on XLISP-PLUS (David Betz, Tom Almy, Luke Tierney, et al), and has an object oriented interface to the OSF/Motif widget class hierarchy, and a combination of high-level object and functional interfaces to the Xtoolkit, Xlib, and underlying Unix system libraries. This environment significantly simplifies the construction of GUI-based applications, and makes these applications easier to modify and extend throughout the software life-cycle. It allows for the development of extensible applications in a safe execution environment -- errors in a new module won't destroy the whole system.
In addition to application development, WINTERP's features make it a good tool for learning about and experimenting with the capabilities of the OSF/Motif UI toolkit. Its rapid prototyping features allow UI and application designers to more easily play "what if" games with different interface styles.

is a basic interpreter written entirely in C++ without the use of lex or yacc. It shows how one can create a compiler or interpreter using some simple classes to parse and/or execute script code. It is a good way to fully understand how a parser/compiler actually works, at least that was the original purpose of this project. Later I added the ability to run shell commands just like in bash scripting and this gives the project also some nice practical use.

Finally a scripting language which has an easy syntax (for some reason bash just doesn't work like I want it too :). If you're also one of those people, like me, who needs to look at the man pages over and over again before being able to write that simple bash script that does not give parse errors, this project is probably worth looking at.

is a new language optimized for rapidly prototyping XML Web services. It delivers both power and simplicity. The language is as easy as BASIC and as powerful as LISP . It is a pure Web services Object Oriented platform that uses the ConciseXML™ syntax and provides OO Capability security.

V is for ...

is intended as an easy-to-use programming, shell and script language with a syntax similar to C/C++, Pascal or Basic. vipsi can be used interactively as a shell, as a pocket calculator, for shell scripts or for CGI scripts.

is a general-purpose visual programming language (VPL) based on object-orientation. Visula programs are diagrams that are edited in a graphical editor. Programmers don't write software - they draw it!

U is for ...

- The UFO Project - The United Functions and Objects project has developed a programming language which unites functional and Object Oriented Programming techniques. A large subset of UFO is a pure functional language incorporating the OO notions of classes, inheritance, and dynamic binding. However, UFO as a whole is not a pure functional language. It has stateful objects, which allow programs to be written in a concurrent object-oriented style where appropriate. Safeguards are provided, both in the semantics of operations on stateful objects and in the type system, to minimise the problems associated with introducing state.

is a "modern dialect" descending from the Icon programming language. Unicon incorporates numerous new features and extensions to make the Icon language more suitable for a broad range of real-world applications.

Unicon is a superset of Icon with "looser slots and a higher payback" to use Las Vegas terminology. It adds objects, networking and file systems access, execution monitoring and visualization, and an ODBC database interface that operates on local files or across a network with SQL database servers. It is portable to (minimally) Linux, MS Windows, IRIX and Solaris environments. Part or all of Unicon will port readily to other Icon 9.4 platforms.

T is for ...

is a mixed BrainF**k/Forth metaphor: A Toadskin program is the definition of a word using built-in words and words defined using built-in words. Words may be one character in length. Oh. And watch out, the argument stack is a ring buffer, but the function stack isn't. The built-in words are mostly BrainF**k syntax where appropriate.

is a minimum procedural language. It is small, portable, procedural, block-structured, recursive, almost typeless, and to some degree object-oriented.

stands for Trivial Portable Framework Library. It includes several classes for command line and configuration files parsing and handling, strings and memory buffers handling, sockets workaround (server and client).

It features simple (trivial) usage of every class. This library was written from API side, and then implemented in C++.

Command line and config file handling is very customizable: there is a possibility of setting up various special properties such as quoting characters, deliminator strings, file comment prefixes and others. It supports several common data types such as booleans, long and string.

Socket communication classes are very intuitive and easy to use.

Strings and buffers classes makes usage of strings and buffers just trivial.

is a template scripting language implemented in C++, designed to be integrated with C++ programs. It is intended as a fast, lightweight replacement for fullblown scripting languages, providing an easy interface for embedding TPT scripts in C++ code. The TPT language was originally based on PML.

The TPT interpreter runs in one pass, avoiding expensive compilation. The language relies on C++ streams for I/O, making TPT more easily portable, small, and fast. There are no bulky modules to include. TPT does not execute as a program or script. It instead translates templates to text, and relies on the C++ program to decide what to do with the text.

What is TPT used for? At this time, TPT is used for generating CGI web pages, C and C++ source code, Make files, and e-mail messages.

is a very high level programming language designed mainly for the beginners of the programming, to develop a thorough understanding of the fundamental concepts of languages.

is an universal code generator based on its own template language. It can be used for generating any texts, such as program source in any language, HTML documents, or even texts in natural languages. Possible applications are similar to preprocessors (such as M4) and to PHP-like tools.

The inspiration was mainly Clarion template language with beautiful "embed/emit" commands. This feature actually mimics human activity during code writing: author (programmer - alive code generator) never writes text linearly, he rather moves over files inserting pieces of code here and there.

is a string substition language; it is intended to be used as an extention language. Tint Emacs is an emacs clone for Win32, Mac OS X, Darwin, and Linux. It uses Tint as its extension language.

is an easy-to-learn, powerful and flexible programming language. Create powerful and robust Windows programs quickly and easily!
With Turbo/PL's short learning curve and high performance, beginners and professional developers alike can create powerful, full-featured Windows software-applications without previous experience with the language.

S is for ...

- Generic shell script compiler. shc creates a stripped binary executable version of the script specified with -f on the command line. shc itself is not a compiler such as cc, it rather encodes and encrypts a shell script and generates C source code with the added expiration capability. It then uses the system compiler to compile a stripped binary which behaves exactly like the original script. Upon execution, the compiled binary will decrypt and execute the code with the shell -c option. Unfortunatelly, it will not give you any speed improvement as a real C program would.

is a multi-platform programmer's library designed to allow a developer to create robust multi-platform software. It provides facilities required by interactive applications such as display/screen management, keyboard input, keymaps, and so on. The most exciting feature of the library is the slang interpreter that may be easily embedded into a program to make it extensible.

(Single Assignment C) is a strict purely functional programming language whose design is focussed on the needs of numerical applications. Particular emphasis is laid on efficient support for array processing. Efficiency concerns are essentially twofold. On the one hand, efficiency in program development is to be improved by the opportunity to specify array operations on a high level of abstraction. On the other hand, efficiency in program execution, i.e. the runtime performance of programs both in time and memory consumption, is still to be achieved by sophisticated compilation schemes. Only as far as the latter succeeds, the high-level style of specifications can actually be called useful.

In order to facilitate the compilation to efficiently executable code, certain functional language features which are not considered essential for numerical applications, e.g. higher-order functions, polymorphism, or lazy evaluation, are not (yet) supported by SAC. These may be found in general-purpose functional languages, e.g. Haskell, Clean, Miranda, or ML.

In order to overcome the acceptance problems encountered by other functional or array based languages intended for numerical / array intensive applications, e.g. Sisal, Nesl, Nial, APL, J, or K, particular regard is paid to ease the transition from a C / Fortran like programming environment to SAC.

- To develop a simple scripting language engine (SIL) to run under MS-DOS console, Win32, and Linux console.

(Second Interpreter of Scheme Code) is an extensible Java based interpreter of the algorithmic language Scheme. SISC uses modern interpretation techniques, and handily outperforms all existing JVM interpreters (often by more than an order of magnitude).

In addition, SISC is a complete implementation of the language. The entire R5RS Scheme standard is supported, no exceptions. This includes a full number tower including complex number support, arbitrary precision integers and floating point numbers, as well as hygenic R5RS macros, proper tail recursion, and first-class continuations (not just the escaping continuations as in many limited Scheme systems). SISC also attempts to implement the standard as correctly as possible , while still providing exceptional performance .

- Machine Independant SMAL assembler and linker supports conditional and macro assembly and all linkage editing operations commonly associated with languages such as FORTRAN and C. It comes with a user's manual that also explains how to customize it to support a variety of machine instruction sets.

is a Turing-Complete assembly-like language with no jumps.

- 1.0 release of ``The Macro Implementation of SNOBOL4 in C'' (CSNOBOL4)

This is a free port of the original SIL (SNOBOL4 Implementation Language) "macro" version of SNOBOL4 (developed at Bell Labs) with the `C' language as a target.

SNOBOL4, while known primarily as a string language excels at any task involving symbolic manipulations. It provides run time typing, garbage collection, user data types, on the fly compilation. It's primary weakness is it's simple syntax, and lack of "structured programming" and "object oriented" constructs.

However some consider the spareness of SNOBOL4 syntax a strength when compared to some "modern" agglomerations such as Perl.

The latest release can be found at

- A simple interpreter of a pseudo assembler language. A command line interface (dos and later *nix) and a win32 gui interface are available.

is a language that helps you do exploratory programming. It was developed to test the idea that visual programming, logic programming, and programming with sets (with partitioning constraints) are highly complementary approaches to programming that when combined produce a good language for exploratory programming. The implementation of SPARCL is only an academic research version: it demonstrates of some of the possibilities of the SPARCL approach. The user environment for the two dimensional representation is fairly complete and is reasonably performant, so you can get an idea of what it's like to build and "read" SPARCL programs. Its most notable drawback is that the interpretation of SPARCL programs is very slow. Also, the three-dimensional representation implementation is rudimentary.

SPARK stands for the Scanning, Parsing, and Rewriting Kit. It formerly had no name, and was referred to as the "little language framework." The first version (circa 1998) was described in the paper Compiling Little Languages in Python at the 7th International Python Conference.

(Synchronizing Resources) is a language for writing concurrent programs. The main language constructs are resources and operations. Resources encapsulate processes and variables they share; operations provide the primary mechanism for process interaction. SR provides a novel integration of the mechanisms for invoking and servicing operations. Consequently, all of local and remote procedure call, rendezvous, message passing, dynamic process creation, multicast, and semaphores are supported. SR also supports shared global variables and operations.

SR has been used at a number of universities and labs for course work and research projects involving concurrent programming. It has been used in concurrent programming courses to reinforce concepts with small programming projects and with larger projects such as experiments with parallel algorithms, replicated databases, distributed simulations, and parts of distributed operating systems such as file systems and command interpreters. SR has also been used as a tool in several masters theses and doctoral dissertations to conduct experiments in parallel and distributed programming and to implement larger systems such as a system for mixed language programming, one for distributed implementation of graph algorithms, experiments with load balancing algorithms, and experiments with upcall program structures.

SR is the predecessor to the MPD programming language, which provides the same capabilities using the syntax described in Foundations of Multithreaded, Parallel, and Distributed Programming.

was inspired by the classic stack language STOIC. STOIC was developed circa 1977 by Jonathan M. Sachs while at the Biomedical Engineering Center for Clinical Instrumentation under the Massachusetts Institute of Technology Program in Health Sciences and Technology. STOIC was itself preceded by a language called FORTH, developed circa '68 for the National Radio Astronomy Observatory in Charlottesville Virginia by Charles H. Moore. Moore, though clinically insane, has continued to extend his language over the years. At the time of this writing FORTH is known to him as colorForth; One imagines that these colors are much like those present in his twisted visions and terror filled dreams. Sachs, however, is now dabbling in software for the Pocket PC architecture, and appears to have all but forgotten about STOIC. At one point in the early '80s, a fellow named Ernest E. Bergmann attempted to reincarnate STOIC in a language dubbed PISTOL (Portably Implemented STack Oriented Language). This implementation had its roots in BDS C, and remains something of an amusement.

STOICAL is vastly different from its predecessors. Primarily because so much has changed since the decades ago that they were developed. Today STOICAL is powerful and general enough to be used as a high performance replacement for semi-compiled and interpreted languages like Perl, Python, SED and Awk. And because of STOICAL's advanced support for networking and concurrent threads of execution, it can be used to write efficient long-running servers and daemons that would normally need to be written in C. The intent here is not to explore the intricacies of archaic systems, but to create a new and modern language, well suited to the world as it exists today. STOICAL might therefore be more accurately represented by the recursive acronym SINS, SINS Is Not STOIC, but this word has a remarkable stigma attached to it ;-)

is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages.

This is a free BASIC interpreter. Is it just another after the so many costly and free interpreters? Well, you can decide, here it goes:

ScriptBasic implements a rich set of instructions that are available under Win32 as well as under Linux/UNIX. Programs written in ScriptBasic are portable unless you work hard to insert some system specific code.

If you miss some functions in the language itself there are external modules that implement several features, like CGI handling, MySQL access, regular expressions, graphical user interface, NT/UNIX specific functions (in case you really need something system dependant) and several others.

If you need some more that is not currently available you can ask for it on the ScriptBasic mailing list or you can easily write your own modules in C. ScriptBasic internals, source code and interfaces are well documented. To get a jump start you can even listen to audio/slide show tutorials. Subscribe to the mailing list now!

ScriptBasic is fast, it generates a compact internal code, which is interpreted. This internal code occupies a single, continuous memory chunk and is usually saved into a cache file. The cache file is automatically checked by ScriptBasic and thus it compiles the source only when needed.

You can also save this code into separate file and deliver it as your application without giving out your source code. This is to protect your intellectual property if you wish to use it. What is more ScriptBasic can be compiled to C and this way you can generate standalone executable on UNIX as well as on Win32 operating systems free of charge.

To program web application you can use ScriptBasic as a CGI interpreter, but there is even a better way. ScriptBasic is integrated into a standalone webserver that executes ScriptBasic programs in a single process without the CGI overhead lighting fast. Under Windows NT you can install this web server as an NT service and use it several ways. This application named Eszter SB Application Engine is supported by the CGI and the MT module allowing you to use in-memory application and session variables without file read/write overhead.

is a free multipurpose C-like scripting library. The idea was to make a script engine for any purpose you would need. This can be for AI in the game, for macros in an editor or whatever. This is for things you cannot (or don't want to) have compiled (hard-coded) inside your program.

Self is an object-oriented programming language and associated
programming environment.

It is close in spirit and semantics to Smalltalk:

  • It is a pure object-oriented language, i.e., everything in the computational domain of Self is an object.

  • Its syntax borrows heavily from Smalltalk.

  • As in Smalltalk, variables are of unrestricted type.

  • It uses blocks - objects which behave like procedures - to implement control structures.

  • Programs are constructed incrementally within the programming environment. An exploratory style is encouraged.

However, it differs from Smalltalk in several important respects. The principal force guiding the design of Self was the desire for simplicity and concreteness. This force is manifested thus:
  • Self is considerably simpler than Smalltalk in syntax and semantics.

  • More of the basic facilities in the Self system are implemented in
    Self, itself.

  • Self has no classes. Instead a more direct object-based inheritance
    mechanism is provided. The programming environment facilitates direct
    manipulation, in which the programmer communicates with objects directly (or appears to), rather than applying "tools" to effect changes.

- The Shakespeare Programming Language - The design goal was to make a language with beautiful source code that resembled Shakespeare plays. There are no fancy data or control structures, just basic arithmetic and gotos. You could say we have combined the expressiveness of BASIC with the user-friendliness of assembly language.

SheerPower 4GL
SheerPower 4GL is the Next Generation Programming Language for Windows. Novices, hobbyists and professionals all benefit from using SheerPower 4GL!

It's unique programming language capabilities make it the ideal general-purpose language for application development, ensuring high programmer productivity. SheerPower 4GL is easy to learn. Most programmers are writing SheerPower 4GL applications within a few hours.

SheerPower is a full development language, but shares many advantages with scripting languages -- such as ultra-fast development speeds and ease of learning the language. SheerPower can be used to write programs of any size, from simple-input programs to vast database applications. SheerPower may look somewhat similar to that of a structured BASIC language, but SheerPower is beyond BASIC!

CodeWorks Inc. introduces SiMPLE, a new beginner-friendly programming language for kids (and adults) who are looking for a new way to have fun with their computers. (SiMPLE currently works only under Windows)

(Simplicity itself generates interesting languages...) is an interpretted (sic), object-oriented programming language. It features a LISP-like syntax, a Self-like object model, garbage collection, exceptions, continuations, lexical scoping, optional parameter type checking, optional lazy evaluation, among other things. The goal of Sigil was to eliminate arbitrary, unnecessary distinctions in a programming language, such as the distinctions between programs and data, classes and objects, properties and methods, functions and language constructs, etc. I'll add a little more information at a later date. For now, you can download the source code or view the language reference manual

is a simple programming tool for scripting languages (Perl, PHP, Python, Ruby, TCL) written in Obj-C/Cocoa.
It can be used by experienced developers to write and test on the fly small routines, and is a good solution for educational purposes.
Do not use it in production environments or to manage large projects.

is a general purpose computer programming langauge that avoids the syntatical tedium of langauges such as C, APL, and assembly, but includes the useful features of these languages. The three main goals of the Sirius language are 1) ease of use, 2) efficiency, and 3) portability. The syntax will be most familiar to Pascal and BASIC users. Like C, only program structures (such as loops, IF...THEN constructs, identifier declarations, etc) are defined by the compiler itself. Most "statements" are routines linked in at link-time. The richness of Sirius is derived from its small number of compiler constructs, the flexibility of the variable definitions, and the number of standard library functions. The compiler knows about these standard routines and performs automatic data type conversion where necessary, yet allows the programmer to redefine any routine as if it had never been defined in the first place.

is a Smalltalk/Self dialect and environment
based on semantic extensions to Smalltalk-80 while retaining the
human-friendly syntax. Slate is primarily based on the choices of
combining the flexibility of object-specific behavior and expressiveness
of multi-method dispatch into one coherent form. The environment heavily
borrows many good ideas from other systems, focusing on integration of
things long experimental into one coherent whole.

Slate is intended to be useful in every role that Squeak and Self are,
and to push the boundaries farther in the areas of dynamic media and
interactivity and flexibility. These will take time to demonstrate, as
the environment is currently still based on console interaction, but the
framework is already in place for forward progress.

(SB) is a simple computer language, featuring a clean interface, strong mathematics and graphics. We feel it is an ideal tool for experimenting with simple algorithms, for having fun.

SmallBASIC IS NOT A DEVELOPER TOOL FOR PROFESSIONAL PROGRAMMERS. Please don't ask us to turn it into one. We value the simplicity of a console more than the beauty of a performance-hogging GUI.

Socket Script
- SScript is a socket scripting language that allows you to easily make networking clients or servers to accomplish simple tasks.

is a high level imperative/OO programming language, designed to be a powerful scripting tool that fits in the size, memory bandwidth, and real-time requirements of applications like games.

is an advanced scriptable RPN calculator for Mac OS X. It features the GNU Kawa Scheme interpreter which allows users to build custom functionality by way of short Scheme programs, or scripts.

is a complete, integrated application platform - a system for developing and deploying applications without the frustrations of integrating multiple different products. Suneido incorporates an object-oriented programming language, client-server relational database software, and application frameworks and components. It includes the development environment used to create applications as well as the client and server required to run applications across networks. Suneido is Open Source - it is provided free, with complete source code.

is an object-oriented language that is entirely based on XML's syntactical structure. Superx++ conforms with the XML version 1.0 specification as published on the W3C web site. Programming in XML itself has great potential and Superx++ pushes the envelope!

R is for ...

is a free programming language based on REBOL.

is a logic-programming language with call-by-value (eager) expressions of non-deterministic, non-ground functions [Boley99]. Clauses are `hornish', succeeding with true(s), or `footed', returning any value(s). They define operations (relations and functions) permitting (apply-reducible) higher-order syntax with arbitrary terms (constants, structures, and variables) as operators. The language explicitly distinguishes structures [passive] and expressions (active). All structures and expressions, not only lists or tuples, can have varying arities. RELFUN generalizes PROLOG's is-primitive to .=, unifying a structure with the value(s) of an arbitrary expression; expressions may become flattened via further .=-calls. Finite domains and exclusions [Boley93] as well as sorts [Hall95] are first-class citizens built into the unification. Extensions include single-cut clauses and relational-functional primitives such as a value-returning tupof. Versions of RELFUN have been used in the hybrid COLAB shell [BoleyHanschke+93], as VEGA's Declarative Representation Language, and for developing ontologies, e.g. for Mathematics International (Mathint Ontology).

is a professional, easy-to-learn and powerful batch- and scripting-language for 32-Bit Windows. With RapidBATCH, you can automate Windows and tune up the productivity of your computer system by writing software tools for your pretensions and usage simply yourself. Due to its high flexibility and easy syntax, RapidBATCH is not only a powerful tool for computer professionals. Even the unskilled newbie creates his first own, useful scripts just after a very short practice.

is compiler construction language developed at the University of Latvia, Institute of Mathematics and Computer Science in 1987. The main data structures are atoms, lists and labelled trees. The control structures are based on advanced pattern matching. All phases of compilation, including parsing, optimization and code generation, can be programmed in this language in short and readable form.

is a compiler for a programming language (also called ruri). The ruri language mirrors the feature set of IJVM and IJVMA, and the compiler targets those assembly languages.
There's also a demo page, which allows you to type in ruri-language code and have the appropriate IJVM or IJVMA output produced.

Q is for ...

is a powerful and extensible scripting language with advanced symbolic processing and functional programming capabilities. Q is based on term rewriting. Consequently, Q scripts are just collections of equations which are used to evaluate expressions in a symbolic fashion. Despite its conceptual simplicity, Q is a full-featured functional programming language with a modern syntax, curried function applications, dynamic object-oriented typing, exception handling, and POSIX multithreading. Scripts are executed in a bytecode interpreter which byte-compiles scripts in an eye blink and runs them about as fast as interpreted Lisp or Haskell. The interpreter provides a built-in symbolic debugger which allows you to trace the reductions performed during expression evaluation. Q also has a libtool-based Q->C interface which makes it easy to extend the interpreter with your own primitives written in C. Conversely, the new C->Q interface (added in Q 5.0) allows you to embed the interpreter in your C/C++ applications.

(Quite Unusually Odd Text Engine) is a language that is built to be wrapped around other languages (get it? Quote? Heh). You can write a program in QUOTE and, using the QUOTE Code Compiler, you can generate C or Perl source code, or even interpret it like a scripting language. QUOTE is a non-Turing complete language that features C-like syntax.

(Pronounced kwo-go is a Langiage based on a mix of Tcl and Logo. It implements the Turtle graphics primatives for drawing on a canvas. The program has been designed to teach 8 to 10 year olds the principles of programming. That is Sequence, Selection , and Iteration

Quick Macros
(QM) is a universal and extensible Windows automation program, designed to make your work more convenient and productive. You can create or record macros to automate repetitive tasks, e.g., insert text, launch programs, copy files, simulate clicks on menu items, buttons and links, automatically close annoying popup windows. You can program QM to perform complex tasks, e.g., process text, programmatically interact with applications. You can add custom toolbars to any window, use hot keys or mouse movements to switch to another window or show a custom menu.

Wednesday, February 22, 2006

P is for ...


is a programming language designed to combine the simplicity of scripting languages like PHP and Perl with the power and speed of C++ and Python.


is an interpreter of 4 object-oriented scripting languages:
  • paxBasic
  • paxC
  • paxPascal
  • paxJavaScript
The key features of the paxScript are:
  • All pax-languages support such concepts of the modern programming as namespaces, nested classes, inheritance, static(shared) members, indexed properties, default parameters, overloaded routines, operator overloading, delegates, exception handling, regular expressions, conditional compilation. If you know VB.NET, C# or Object Pascal, you are already familiar with paxScript.
    • Cross-language integration. For example, you can use modules written in paxBasic and paxC in your paxPascal scripts and vice versa.
    • Separate compilation of the modules.
    • Direct calling dll-defined routines. All calling conventions register, pascal, cdecl, stdcall, safecall are supported. (See demo.)
    • Embedding scripts into html pages.
    All paxScript languages support LISPPA technology which considerably extends the applicability of imperative programming languages in the symbolic computations and AI applications.

    TPaxScripter component allows to embed paxScript interpreter into your Delphi or Borland C++ Builder application, so you can extend and customize the application without having to recompile it.

    Using TPaxScripter you can
    • Import Delphi classes, routines, constants, and variables.
    • Import Delphi units automatically with paxScript Importer.
    • Convert dfm-files into the paxPascal scripts.
    • Call script-defined functions.
    • Save/Load compiled scripts to/from a stream.
    • Unite source code modules and compiled (binary) modules in your script project.
    Moreover, you can add full compiled script to the script project.
    • Build the code explorer tree.
    • Customize compilation process and error handling.
    • Use scripter in the debugger mode (breakpoints, step into, trace over, run to cursor). The component comes with full source code of paxScript IDE, so you can use it as a base to develop your own integrated environment.
    Source code of the paxScript interpreter and TPaxScripter component is written entirely with Delphi and compatible with Delphi 5, Delphi 6, Delphi 7, C++ Builder 5, C++ Builder 6, Kylix 3. You don't need any extra DLLs or OCXs.

    TPaxScripter component is thread safe. It has small footprint (about 30-40 Kb per extra TPaxScripter instance).


    A polymorph functional language to embed in applications
    PILL is a scripting language for applications. The syntax (based on functional languages) might look weird but it have some advantages (and i like it).
    It contains only a minimal set of functions, applications will have to register new ones via the interpreter's API in order to make it to replay the scripts as wanted.
    This abstraction offers a flexible way to expand scripts abilities to virtually any domain and to allow various applications to share/re-use foreign scripts.


    is a SWIG extension that allows new language modules to be programmed in Python. It's mostly a SWIG wrapper for SWIG itself ;-)


    (pipe) is a universal filter application. It uses plugins to transmit and convert data. They can be nested, so the inner structures can become quite complex (non-linear). The command-line interface is similar to a programming language and very easy.


    The Private COMpiler builds a .COM, .EXE or .ASM file from a given source file.

    Features: Easy to understand programming language, even for those who aren't familiar with assembler, c, Pascal or any other 2nd or 3rd generation language. You can use variables on some important commands.The length of the variable name isn't important and it's case insensitive.

    You can protect your executables using encryption or/and with anti-hacker code.
    You can predefine your compiler arguments using a PCOM.CFG configurationfile.
    You can compress the executable right away, so it's as small as possible.
    And finally, PCOM-executables support long filenames.


    - Development Assistant for PL/M (DA-PL/M) offers new possibilities of development and maintenance of PL/M applications. This program is completely project oriented and it is very easy to handle both, small and large projects.


    is a simple, powerful way to add custom scripting to any program. A basic C parser and interpreter is included, and new scripting languages can be designed easily.

    Setup of new commands and languages requires only minor programming changes. The C language module with full source code is included in the freeware release, to serve as an example for new languages.

    The PLC library is available as freeware, and the complete source code to PLC Pro may be licensed for a nominal fee.


    • A free open source version of the (commercial but very cheap and highly recommended) Euphoria programming language running on the Parrot virtual machine (which is also open source and free).
    • A simple, easy to learn, fast, lightweight, interpreted and/or compiled, cross-platform, open source, and several other buzzwords, programming language, with a searchable library of over 1,200 user contributions freely available.
    • A bad pun on Pete+Lomax+Euphoria+Parrot.

    PascalWorks 2

    is a pascal interpreter with syntax highlighted editor and templates. Ideal for use at home or at school to learn programming. Help file included.


    is a visual programming tool designed for a simple and fast generation of the programs for Windows 95/98/NT/ME/2000/XP. Its principal characteristic is the graphical presentation of the program structure. The program sections are assembled using the mouse like a jigsaw puzzle. Thanks to the justification check of the element combinations, carried out already at the time of the program generation, there is no chance of syntactic failure origination. The program presentation by means of a tree structure enables a considerable improvement of the program lucidity. The creation of the program is quickly becoming extraordinary easy and flexible.

    Peter is intended for a broad range of the users. By using it, even the children of the pre-school age are able to draw pictures and teach their little rabbit to move. On the other hand, there are a lot of powerful functions intended to use by skilled programmers. It is not Peter's goal to train programmers out of all users. Its objective is to make the program generation accesible to all who want to create. No knowledge in the programming or computer areas is necessary. Everything is covered by the numberless functions. This is an effective mean for training the logical thinking, imagination, and aesthetic feeling.


    is a small, pure language for building applications from software components. Piccola is small in the sense that its syntax is tiny, and it is pure in the sense that it provides only compositional features -- computation is performed entirely by components of the host programming language.


    is a tiny but expressive programming language that was especially designed to teach advance computer science concepts to students in other sciences than computer science (such as Physics and Chemistry). In a sense, Pico can be seen as a non-trivial marriage between the power of languages like Scheme, and, the standard infix notation students are used to from ordinary calculus. A.o., Pico features garbage collected tables (i.e. arrays), higher order functions, objects, meta programming and reflection. But above all, Pico is small! Really small!


    is a language in the ML tradition, formed by adding a layer of convenient syntactic sugar and a static type system to a tiny core. The current release includes a Pict-to-C compiler, reference manual, language tutorial, numerous libraries, and example programs.The core language - an asynchronous variant of Milner, Parrow, and Walker's pi-calculus - has been used as a theoretical foundation for a broad class of concurrent computations. The goal in Pict is to identify high-level idioms that arise naturally when these primitives are used to build working programs - idioms such as basic data structures, protocols for returning results, higher-order programming, selective communication, and concurrent objects. The type system integrates a number of features found in recent work on theoretical foundations for typed object-oriented languages: higher-order polymorphism, simple recursive types, subtyping, and a powerful partial type inference algorithm.


    The Pizza language is an extension to Java with three new features:
    • Generics (aka Parametric polymorphism)
    • Function pointers (aka First-class functions)
    • Class cases and pattern matching (aka Algebraic types)

    Furthermore you can use the Pizza compiler embedded into other applications.


    is a new programming language. It utilizes powerfull static typing techniques. It was designed to fix some frustrations that people were having with c++ java and c#. It is bsd licensed and free for both opensource and commercial use.


    - , the Popular Assembler Project - is an assembler (i.e. an assembly language compiler) designed to meet the needs of all assembly language programmers out there... This is NO easy mission, I know...


    is a new dynamic object-oriented language that improves upon the excellent language Python. While not compatible with Python, Prothon is close enough for Python code to be easily ported to Prothon.
    Prothon is built upon the more flexible foundation of Prototypes rather than the classes of Python, while still fully supporting classes. This allows other object paradigms than classes to be used like acquisition and maybe even aspects.


    is a visual dataflow programming environment for interactive multimedia, similar to Max and jMax.

  • Friday, February 17, 2006

    O is for ...


    is a simple and safe object-oriented language created by N.Wirth, the author of Pascal and Modula2. It is statically strongly typed and has garbage collection. Most of good ideas incorporated in design of Java were in Oberon2 long before. OOC is an open source project to produce a family of optimizing Oberon2 compilers. The compiler with an ANSI C back-end, oo2c, is quite mature, and provides a complete and convenient Oberon2 development environment. It comes with a rather comprehensive standard library, Code Navigator, and an Emacs mode. It is easy to call C functions and libraries from Oberon2.


    is a general purpose object-oriented programming language. It is designed to be simple to learn, easy to use, yet still powerful, combining the convenience of an interactive interpreter with many of the features of Java:
    • a simple java-like syntax
    • class system, with single inheritance and mixins
    • private/protected/public fields and methods
    • exceptions for error handling
    • synchronization and threading
    • compiles to bytecode for higher performance
    • osdoc: a javadoc-like tool to extract API documentsfrom src code, plus API docs accessible reflectively
    • XML-RPC support
    • Windows COM support
    • regular expressions (requires java v1.4 or later)
    Plus, it's free! And since it is written in Java, programs written in ObjectScript can take advantage of existing Java code and libraries, like Swing. ObjectScript programs can not only create instances of Java objects, call Java methods, access public fields, access java bean properties, but can also extend Java classes, and implement Java interfaces. Since it can be interactively interpreted, ObjectScript is the perfect way to debug or learn Java systems. And since it supports extending Java classes and interfaces, it can add sophisticated scripting to an existing Java application.


    is a powerful stack-based, multi-threaded, interpreted, general purpose programming language similar to PostScript. It can be embedded as an extension language similarly to ficl (Forth), guile (scheme), librep (lisp dialect), s-lang, Lua, and Tcl.


    is a highly portable and free implementation of the Comal programming language written by moi. Currently supported platforms are Unix, MsDos and Win32 (95, 98, NT, 2000, XP and whatever they come up with next :-)

    Comal is a crossover between Basic and Pascal, with the best features of both and none of the drawbacks of either.


    is an openly available specification of the Spice language - a modern programming language with some nice XML processing features. It is designed with the needs of part-time or occasional programmers in mind. The language features are properly separated and their corner cases have been eliminated. This design means that if you only use Spice occasionally, you're likely to find it easy to come back to despite the breaks.


    is an interpreted dynamic parser which is well suited to rapid development of parsing solutions, starting from rapid language prototyping to full fledged compilers.
    OpenZz is a dynamic LALR(1) parser which allows its grammar to be modified and extended by commands written in its own language as well as through functionality provided by external libraries. OpenZz is implemented as a C library and exports C-bindings, so it can be joined with other code libraries both by static linking and runtime module loading.

    Zz is a very sparse language: few operations are intrinsically supported. The key of Zz is the syntax extension statement. In the current release the following are available as predefined statements: assignment, print, evaluation of simple expressions, and a limited number of other basic instructions. In principle there is no need of Zz instructions, except for only the syntax extension capability. The intrinsic Zz statements are however useful for purposes of exercise and in the early stages of application development.


    Ox is an object-oriented matrix language with a comprehensive mathematical and statistical function library. Matrices can be used directly in expressions, for example to multiply two matrices, or to invert a matrix. Use of the object oriented features is optional, but facilitates code re-use. The syntax of Ox is similar to the C, C++ and Java languages. This similarity is most clear in syntax items such as loops, functions, arrays and classes.

    N is for ...


    - This software performs an original script language. Little batch processing etc. can be created easily. It operates by the console.C-language-like syntax.


    - Modification nScript by Tomoaki Nakashima.


    is a traditional scripting environment for the Apple Macintosh. The shell is available in two forms. A light version, called nShell(tm), is freely distributable for non-commercial purposes. A second version, called nShell-Pro(tm), [was] available as a commercial product [link is now to pro version source]. Our goal is to make the shell environment available to as many users as possible, while providing serious users with the support and reliability of a full commercial product.


    is a portable/multi-platform, lightweight TCP/UDP socket scripting system. It is intended to automate situations, built on a word-to-word ruleset response system. It includes wildcard support, character replacement, random replacement, argument inclusion, server timeout, initial send, display altering, multiple character dump formats, telnet protocol support, logging, program to socket dumping, executable ruleset support, reverse binding, module support, data truncation, data formatting, permission options, virtual hosting support, history storage, dynamic storage variables, directory placement, character omitting, timed rules, background support, syslog support, routing support, socket options, interactive mode, and graphical user interface support.


    stands for Natural Language Processing Toolkit, and is part of the Traduki project. NLTPK is written in C and Lua programming languages and is released under the GNU Library General Public License: in short, it allows you to use it for free, even in commercial products, without having to release the code of your program (but you have to make public changes to the library).

    Despite still in alpha stage, NLPTK can be used in many different kinds of software, like machine translation, text analysis, spam filters, adventure games, etc


    - Nullsoft Scriptable Install System - is a tool that allows programmers to create such installers for Windows. It is released under an open source license and is completely free for any use.

    An installer is the first experience of a user with your application. Slow or unsuccesful software installations are the most irritating computer problems. A quick and user friendly installer is therefore an essential part of your software product.


    (Not another scripting language) is a small, simple, yet full-featured language designed as extension language in situations where larger languages are simply to large or unwieldy to embed. It supports OOP syntax and functional programming, works on the traditional data realm of strings, vectors, and hashes, and does it all in less than 100k of ANSI C. Please note that this is not the NASL extension language from the Nessus project.


    is a new programming language. It extends the ideas behind object-orientation in order to better support modular programming and static type safety. It also 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.


    is a programming language based prototyping environment with powerful programming and scripting capabilities. Nickle supports a variety of datatypes, especially arbitrary precision numbers. The programming language vaguely resembles C. Some things in C which do not translate easily are different, some design choices have been made differently, and a very few features are simply missing.

    Nickle provides the functionality of UNIX bc, dc and expr in much-improved form. It is also an ideal environment for prototyping complex algorithms. Nickle's scripting capabilities make it a nice replacement for spreadsheets in some applications, and its numeric features nicely complement the limited numeric functionality of text-oriented languages such as AWK and PERL.


    is an Object-Oriented language, with a syntax similar to Java or C++, and with advanced high level features such as a strong type system, automatic memory management, and global code optimisation.

    M is for ...


    is a small macro-style tool for maintaining small (or not small) configuration files that tend to change frequently or are deployment specific. An unholy marriage of make, m4, perl and lisp useful for "hands-off" configuration and build environments.


    is a light-weight, cross platform programming language. It is garbage collected and self hosting and produces portable byte-compiled binaries that can be executed on any platform with the appropriate interpreter. Interpreters are available for Linux, DOS (32-bit) and DOS (16-bit) and the interpreter source should be easily compilable for other platforms.

    Back in 1997 I decided, more or less for the hell of it, to design and implement a programming system. Mercat, nee Micron, is that language, and this is it.

    Mercat is not really useful for anything much. It is, on the other hand, an excellent example of how to implement a self-hosted recursive-descent-parsed language and virtual machine. The code is --- I hope --- reasonably easy to understand, and I think the overall design is quite elegant.

    Features include:
    • Garbage collection
    • Portable binary files
    • C-like syntax
    • Associative arrays as a primitive type
    • Real strings
    • Easily expandable through a simple, fast system call interface
    • Self-hosted the compiler and assembler are written in Mercat
    • Text screen interface through ncurses


    is a new programming language that was developed for applications distributed on a small scale. You can make simple applications. Features include: if statements, nested functions, forms, and over 100 functions. To run Mocha you'll need the Visual Basic 6.0 runtime file (msvbvm60.dll), the Microsoft Common Dialog Control, and the Windows Common Controls. For the actual Mocha applications though, you only need msvbvm60.dll.


    MPD is a new programming language that has a syntax very close to the one used in the book Foundations of Multithreaded, Parallel, and Distributed Programming. The name of the language comes from the first three letters of the main words of the title of the book: Multithreaded, Parallel, and Distributed. These words also capture a distinguishing aspect of the language, namely that it supports all three of these concurrent programming techniques.

    MPD is implemented as a variant of the SR programming language. It has a different parser, but it uses the same intermediate form and run-time system as SR. Consequently, MPD provides the same variety of concurrent programming mechanisms as does SR.

    The language overview page contains links to a tutorial on the language, sample programs, a synopsis of the syntax of MPD, and a description of how to compile and execute programs. The MPD distribution contains manual pages and numerous additional examples.

    MPD programs can execute on single processors, shared-memory multiprocessors, or clusters of (homogeneous) processors. The implementation supports a variety of different kinds of processors and Unix systems. See the download page for further information.


    is a command line utility that can make using Windows a much less annoying experience by allowing you to start programs simply by typing their command lines, instead of wading through dozens of menus.

    This is great for fast typists, people who are used to UNIX, and generally anyone who doesn't like the idiot-proof way Windows tends to do things.

    MCL is highly customizable, widely extensible, very powerful, and convenient. It was written using Microsoft Visual C++ 6.0, and contains nearly 6000 lines of C++ code. Because it does not make use of MFC, Delphi, or Visual Basic runtime code, memory usage is low, download size is small, and performance is high.


    is a simple typeless language which is based on BCPL. It makes extensive use of pattern matching somewhat related to that used in ML and Prolog, and some other features come from C.
    An interpretive implementation of MCPL has been developed in a style similar to the BCPL Cintcode implementation. It currently works well enough to run several demonstration programs. Experimental native code versions for Linux and the DEC Alpha are included as part of this distribution.


    stands for MIX Development Kit, and provides tools for developingand executing, in a MIX virtual machine, MIXAL programs.
    The MIX is Donald Knuth's mythical computer, described in the firstvolume of The Art of Computer Programming, which is programmed usingMIXAL, the MIX assembly language.
    MDK includes a MIXAL assembler (mixasm) and a MIX virtual machine(mixvm) with a command line interface. In addition, a GTK+ GUI tomixvm, called gmixvm, is provided and, in case you are an Emacs guy,you can try misc/mixvm.el, which allows running mixvm inside an EmacsGUD buffer.
    Using these interfaces, you can debug your MIXAL programs at sourcecode level, and read/modify the contents of all the components of theMIX computer (including block devices, which are simultated using thefile system).


    - Meta Language
    METAL is a 100% free extended BASIC language metacompiler for Mac.
    The ultimate goals of METAL are to bring back the spirit of 1980s programming and provide both beginners and advanced developers



    ist ein Programm für alle Windows (32-Bit) Systeme mit dem Sie Ihre Arbeit am PC automatisieren können, d.h. Aufgaben die Sie bis her immer von Hand mit der Maus oder Tastatur gemacht haben können Sie jetzt von MacroX erledigen lassen, einfach und schnell!


    Maude is a high-performance reflective language and system supporting both equational and rewriting logic specification and programming for a wide range of applications. Maude has been influenced in important ways by the OBJ3 language, which can be regarded as an equational logic sublanguage. Besides supporting equational specification and programming, Maude also supports rewriting logic computation.
    Rewriting logic is a logic of concurrent change that can naturally deal with state and with concurrent computations. It has good properties as a general semantic framework for giving executable semantics to a wide range of languages and models of concurrency. In particular, it supports very well concurrent object-oriented computation. The same reasons making rewriting logic a good semantic framework make it also a good logical framework, that is, a metalogic in which many other logics can be naturally represented and executed.
    Maude supports in a systematic and efficient way logical reflection. This makes Maude remarkably extensible and powerful, supports an extensible algebra of module composition operations, and allows many advanced metaprogramming and metalanguage applications. Indeed, some of the most interesting applications of Maude are metalanguage applications, in which Maude is used to create executable environments for different logics, theorem provers, languages, and models of computation.


    is a simple, object-oriented and strongly typed language.


    - 'Misc Is a Script Compiler' - is a programming language designed especially for performing calculations on large amounts of data. The Misc Engine library is a portable C++ library containing Misc compiler, interpreter and standard built-in functions.

    The main purpose of Misc is to serve as a base engine for other applications. For example, one could create a GUI front-end for drawing graphs using the data generated by a script written in the Misc language. The functionality of the Misc Engine by itself is limited to calculations, data manipulations and simple I/O operations. However its ability to be extended with additional functions makes it a powerful tool.

    Key Features
    • Misc is a high level, procedural language. It's syntax is similar to C,but like most other scripting languages, it supports dynamic variable types.
    • Native data types include booleans, integer, floating point and complex numbers, vectors and matrices up to 4x4 elements and strings.
    • Misc can efficiently perform operations on large data using continuous arrays and lambda functions.
    • Misc is able to operate on complicated, hierarchical data structures.
    • A large number of built-in functions is included in the Misc Standard Module.Additional modules can be easilly created and plugged into Misc Engine.


    is a non-strict functional language specifically designed for an OO envrionment. It can be thought of as a 'light' version of Haskell with the syntax a meld of that of Haskell and the Java/C family.


    is a programming language and development environment for the Apple Macintosh, written and maintained by Mike Hore . It is an object-oriented native-code dialect of the Forth programming language, with origins as a re-implementation of Neon .(Neon is a commercial programming package for the Macintosh that was sold by Kriya Systems, Inc. in the mid-1980s.)
    While Neon died off years ago, Mops has thrived and continued to continued to improve, earning a reputation along the way as being both agile and user-friendly. Uniquely, Mops has included its complete source code in each distribution since its first public release. Seventeen years since its inception, Mops has completed its transition into a native stand-alone development solution for Mac OS X, with its original author still at the helm.
    As a fine example of public domain software, Mops attracts advanced and novice users alike. Whether you have become frustrated with traditional vendor-supported language "solutions", grown resentful of the legal restrictions imposed on you by most developers of commercial software, or even if you never thought you had a reason (before now) to try something different, Mops might be just what you are looking for!



    - My Business Basic - is an open source Business Basic Interpreter/Run-time environment. We are working towards becoming a free, fully functional business basic.

    L is for ...


    is a HTML precompiler for static home page generation. It detects special HTML tags in your page and generates HTML code out of it.
    It supports:
    • file including
    • soft and hard macros
    • menu tree handling
    • image size detection
    • file link generation with reguar expression support
    • multiple languages page generation with character support
    • frames
    • dynamic code generation via a javascript interpreter
    • customizeable init system
    • user tag definitions


    is a new programming language, looking like LISP, but pure Object-Oriented. It is called LITTLE, because it, in the origin, has been planned to be as small and customizable as possible to serve as an extension language. It's current implementation, however, is not that little ...

    • Dynamically Typed - LITTLE doesn't use explicit type declarations object classes are determined at runtime
    • Multiple Inheritance - classes may have multiple parent classes attributes of common base classes are always inherited once, ambiguities in method inheritance must be explicitly resolved
    • Everything Is Object - classes are first-class objects, as are 'atomar' types like Symbol, Char, Int class methods are fully polymorphic
    • Exception Handling
    • Garbage Collection - the programmer doesn't have to take care of memory deallocation the system automatically detects and collects unreferred objects
    • Built-in Support for DSOs and late binding
    • Native classes and methods - LITTLE offers features for efficient integration of code written in C/C++ (or other compiling languages)
    • Optional support for native threads and asynchronous signals

    (Low-level INterfaced OverLanguage for Extremely Universal Machine-coding) is a lightning fast programming language for everyone who wants to be immune from future system changes. It features complete abstraction from the physical system, yet its applications' speed is closely comparable to that of pure machine language, with an almost 1:1 language-to-CPU instruction ratio. You may think about it as of some sort of Java, but running in low level, and creating stand-alone applications, or you may try to compare it to Forth, but in the end you'll probably find it's very difficult to find LINOLEUM equivalents in any other existing languages; as far as I know, it is unique, it could even be a missing ring in the history of informatics. LINOLEUM gives you an APA (All Pixels Addressable) display to output truecolor graphics controlling and writing every single pixel, as if you were programming in assembly and accessing a linear frame buffer; it gives you the possibility to build your own waveforms and leaves your program the duty (and advantage) of sequencing, even in real time, the samples straight into the program's memory, to playback them upto 44.1KHz over two channels (stereo); it treats the printer as an additional display, where WYSIWYG really means What You See Is What You Get. Combining all this, you can write your own Graphical User Interface, your own graphics engine (and with enough power to perform 3D rendering in real time without absolutely using hardware acceleration, entirely via software), your own digital audio sequencer, and a lot more. It's a REAL cross-platform assembler, and barely the world's fastest cross-platform programming language.


    -- while not yet a hardware description language, may be seen as the first step in that direction.


    - The Lcomp Scripting Engine is a scripting engine written in Visual BASIC for DOS 1.0 that can be used by a programmer to write automatated scripts to perform routine actions in DOS. It can be used as a simple automation tool or a vast programming language


    is a programming language with BASIC syntax, it's a typed and a compiled language, its source is compiled into a platform-independent virtual machine assembler that is later transformed into a platform-dependent representation by the just-in-time compiler. Lemick supports concurrent and distributed programming (multi-threading and distributed multi-threading). Rendezvous are used for message passing; replicas and ultra-weak consistency model implement distributed shared memory simulation. Extension of exception handling mechanism, including distributed version is being developed now. Lemick favors mixed procedural and object-oriented programming style.


    makes it incredibly easy to start programming your own software. There are so many languages out there that can be too complicated and too confusing for a beginner to grasp. Leopard simplifies the process, making programming easy and fun.
    My goal with Leopard is to spark your interest in programming software, and hopefully this will lead you to expanding your skills with other languages. Leopard will get you up and running in very little time, and I hope it's an enjoyable experience for you.


    is a relational programming language that explores the different values yielded by relations by back-tracking rather than parallel execution.
    Ordinary programming languages calculate functions. Sometimes a function is inappropriate. For example, 4 has two square roots, +2 and -2, but an ordinary programming language provides a sqrt function that returns only one of the roots. So if we want to find both roots of a quadratic equation, we have to deal with each root separately. In a relational language, we need only to specify one solution, and the program will find both. This is because it will treat sqrt as a binary relation. A binary relation is similar in concept to a function, but can map an argument to any number of values (including zero).

    Relations have many uses in computer science. The Z Specification Language makes heavy use of relational algebra notation. One reason is that programs are usually required to establish an input-output relationship, but there are often many outputs that are allowable. For example, a program may be asked to find any solution to a problem, or it may be asked to list all solutions, but in no particular order. A functional specification is bound to specify some particular solution or some particular order. A functional specification is usually an over-specification.


    makes it easy to learn to program for Windows. If you're new to programming, you can download Lingo and write your first program very easily. And experienced programmers benefit because Lingo is quick to install and simple to use! Lingo includes a Developer Environment for designing forms, managing projects and debugging.


    is an Open Source object-oriented extension to the Prolog programminglanguage providing the following features:
    Separation between interface and implementation
    Predicate directives (declarations) can be contained inside objects or inside protocols (interfaces), which can be implemented by any object.
    Parametric objects
    Object names can be compound terms containing free variables that can be used to parametrize object predicates.
    Support for both class-based and prototype-based systems
    You may have, in the same application, class-based hierarchies (with instantiation and specialization relations) and prototype-based hierarchies (with extension relations).
    Support for multiple object hierarchies
    No need to be constrained to a single lengthy hierarchy rooted in some generic object.
    Private, protected, and public inheritance
    Logtalk supports private, protected, and public inheritance in a way similar to C++.
    Private, protected, and public object predicates
    Set the scope of your object predicates to match your protocol design and let the runtime system enforce your choices.
    Static and dynamic object predicates
    Any static object may contain both static and dynamic predicates.
    A pre-processor so we can use standard Prolog syntax
    Logtalk uses standard Prolog syntax with the addition of a few operators and directives for a smooth learning curve.
    Event-driven programming
    Predicates can be implicitly called when a spied event occurs, thus minimizing object coupling.
    Component-based programming
    Predicates can be encapsulated inside categories, which can be imported by any object.
    Multi-inheritance support
    Logtalk supports multi-inheritance of both protocol and implementation. An object may implement several protocols and extend, specialize, or instantiate several objects.
    Good performance
    Logtalk code is compiled using the same technics that you use to write efficient Prolog code. In addition, method lookups are cached by the Logtalk runtime engine, greatly improving performance.
    Close integration with the ISO Prolog Standard
    Logtalk is designed for smooth integration with any Prolog compiler that conforms or closely follows the ISO Prolog Standard.
    Compatible with most Prolog compilers
    Logtalk interfaces with a specific Prolog compiler via a minimal configuration file making it compatible with almost any modern compiler.
    Automatic generation of XML documentation files
    Logtalk automatically generates a documentation file in XML format for every compiled object, protocol, or category. The system includes all the necessary XSL(T) files and scripts to convert documenting files to (X)HTML and PDF.


    is an object-oriented programming language designed for researchers, experimenters, and engineers interested in large-scale numerical and graphic applications. Lush is designed to be used in situations where one would want to combine the flexibility of a high-level, weakly-typed interpreted language, with the efficiency of a strongly-typed, natively-compiled language, and with the easy integration of code written in C, C++, or other languages.