Lua is a programming language originally designed for extending applications,
but also frequently used as a general-purpose, stand-alone language. Lua
combines simple procedural syntax (similar to Pascal) with powerful data
description constructs based on associative arrays and extensible semantics.
Lua is dynamically typed, interpreted from bytecodes, and has automatic memory
management with garbage collection, making it ideal for configuration,
scripting, and rapid prototyping.
A fundamental concept in the design of Lua is to provide meta-mechanisms for
implementing features, instead of providing a host of features directly in
the language. For example, although Lua is not a pure object-oriented
language, it does provide meta-mechanisms for implementing classes and
inheritance. Lua's meta-mechanisms bring an economy of concepts and keep the
language small, while allowing the semantics to be extended in unconventional
ways. Extensible semantics is a distinguishing feature of Lua.
Lua is implemented as a small library of C functions, written in ANSI C, and
compiles unmodified in all known platforms. The implementation goals are
simplicity, efficiency, portability, and low embedding cost.
Micro Python is a lean and fast implementation of the Python 3 programming
language that is optimised to run on a microcontroller.
Nickle 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.
This is a port of MLton, the whole-program optimizing Standard ML
Compiler. MLton runs on a variety of platforms, generates excellent
code, has a fast C FFI, profiling, and many useful libraries,
including an interface to the GNU multiprecision library. For more
information, go to the MLton home page.
BASIC-256 is an easy to use version of BASIC designed to teach anybody
(especially middle and high-school students) the basics of computer
programming.
It uses traditional control structures like gosub, for/next, and goto,
which helps kids easily see how program flow-control works. It has a
built-in graphics mode which lets them draw pictures on screen in
minutes, and a set of detailed, easy-to-follow tutorials that
introduce programming concepts through fun exercises.
This is Moscow ML, a lightweight implementation of Standard ML:
The current version of Moscow ML
* implements the full Standard ML language, as revised 1997,
including Modules and some extensions
* yet is backwards compatible with versions prior to 2.00
* implements large parts of the new SML Basis Library
* implements separate compilation
* can produce compact stand-alone executables (a la Caml Light)
* supports quotations and antiquotations, useful for metaprogramming
* supports dynamic linking of external functions
MTASC is the first ActionScript 2 Open Source free compiler.
It can compile large number of .as class files in a very short time
and generate directly the corresponding SWF bytecode without relying
on Macromedia Flash or other tools.
The newLISP is a scripting language for developing web applications and
programs in general and in the domains of artificial intelligence (AI) and
statistics.
The newLISP is a scripting language for developing web applications and
programs in general and in the domains of artificial intelligence (AI) and
statistics.
Nim (formerly known as "Nimrod") is a statically typed, imperative
programming language that tries to give the programmer ultimate power
without compromises on runtime efficiency. This means it focuses on
compile-time mechanisms in all their various forms.
Beneath a nice infix/indentation based syntax with a powerful (AST
based, hygienic) macro system lies a semantic model that supports a soft
realtime GC on thread local heaps. Asynchronous message passing is used
between threads, so no "stop the world" mechanism is necessary. An unsafe
shared memory heap is also provided for the increased efficiency that
results from that model.