• No dll's, ActiveX's, external files, everything compiles into exe with very small footprint;
• Supports OLE Automation calls. Can invoke and operate Word from a script.
• Fast script compilation into PCode & execution;
• Virtual compiler allows to add more languages;
• Allows script debugging: stopping, resuming, evaluating watch expressions, inspection of call stack and more;
• Fast and one time only name resolution done with virtualized and extensible introspectors, that allow to extend and create your own object model;
• Easily extensible array of external functions;
• Easy to create custom object model and publish methods of existing classes;
• Supports dinamic variant arrays;
• Supports parameters passed by value and by address (var, out);
• Allow to compile and evaluate procedures, functions and simple expressions;
• Support exception handling with try..except, try..finally, raise directives and exception variable.

• Complete syntax: DBasic is a mix between Basic and Pascal and makes possible to realize every kind of programs; supports Long strings, Pointers and Recursive functions.
• Fast learning: For the developer, complete documentation, object-oriented interface, easy to use. For the customer, Basic is the simplest programming language.
• Delphi functions: Dbasic can call Delphi functions, so it is possible to perform every task of the application.
• High speed: Scripts are not interpreted, they are compiled into a compact p-code and then executed by an assembly optimized virtual machine. This allows tasks of graphics, math and signal processing.
• Zero DLL, zero OCX: Dbasic is a compact unit which is compiled into the application. A DLL version is optionally available.

Features:

• Can load and execute DFM+PAS files
• Any VCL component / procedure / function can be used in scripts
• Automatical unit import
• Supports subset of Object Pascal language.

Main features:

• Creates proxy objects for all VCL objects.
• Provides read/write access to all published properties in script (including events, object properties).
• Provides ability to assign script procedures to object's events in the script and in the object inspector (in Delphi or in EControl Form Designer Pro).
• Custom technics of methods of objects definition those are accessible through IDispatch.
• Proxy object is an object that implements IDispatch interface, so you may provide access to your VCL objects (for example, forms, data modules) through COM/DCOM connection.
• Integrated script editor based on EControl Syntax Editor.

It is useful for the programmers who want to add scripting ability to their projects. FastScript is written on 100% Object Pascal.

Unique feature of FastScript is ability to use several languages (PascalScript, C++Script, JScript and BasicScript), so you can write scripts using your favorite language.

FastScript doesn't use Microsoft Scripting Host, so it can be used in Windows and Linux environment. It is possible to add a new language - language definition is stored in the XML format, so you can perform it without writing a Delphi code.

Features:

• Multi-language architecture allows you to use a number of languages (at present moment PascalScript, C++Script, BasicScript, JScript). You can add any procedural language (language grammar is stored in XML format).
• You can use multi-language scripts. For example, one module may be written in PascalScript, another one - using C++Script.
• Standard language set: variables, constants, procedures, functions (nested functions allowed) with var/const/defaultparameters, all the standard operators and statements (including case, try/finally/except, with), types (int, float, bool, char,string, multi-dimensional array, enum, variant), classes (with methods, events, properties, indices and default properties).
• Types compatibility checking.
• Access to any object inside your application. Standard libraries for the access to the base classes, controls, forms and BD. Easily expandable library architecture.
• Small footprint - 80-150Kb depending on used modules.

• Variables, Constants
• Standard statements: Begin/End, If/Then/Else, For/To/Downto/Do, Case Of, Repeat/Until, While, uses, Exit, Continue, Break
• Functions (Declared inside or outside script)
• Standard types: Byte, Shortint, Char, Word, SmallInt, Cardinal, Longint, Integer, String, Real, Double, Single, Extended, Boolean, Array, Record, Enumerations
• Importing Delphi functions and classes
• Compiling to a file and running later.

LMD ScriptPack allows to extend functionality of an application by external scripts - source code changes or to rebuild projects is not required. Since release 4 an integrated debugger for handling the supported script languages is included. Release 5 added VCL.NET support, Release 5.1 a native PascalScript implementation is available. Since LMD 2011 relase native VB Script variant (independent of any MS DLL) was added as well.
 
Trial (work while IDE is running)
Source: On purchase/registration
Price: $94

LMD ScriptPack allows to extend functionality of an application by external scripts - source code changes or to rebuild projects is not required. Since release 4 an integrated debugger for handling the supported script languages is included. Release 5 added VCL.NET support, Release 5.1 a native PascalScript implementation is available. Since LMD 2011 relase native VB Script variant (independent of any MS DLL) was added as well.
 
Trial (work while IDE is running)
Source: On purchase/registration
Price: $94
Exe-Demo Included

It supports various documentation modes, from a simple syntax overview, to the SynEdit code-completion templates and XML output.

RemObjects Pascal Script is a popular scripting engine for Delphi developers, that is widely used and very well-rated.

PS-SyntaxDoc is an extension for this scripting engine, that lets you generate a full description of the syntax of your scripting interface and provide your developers and end-users with a better overview of the possibilities of your product.
 
Fully functional
Source: Included

Pascal Script includes the following features:

• Variables, Constants
• Standard language constructs:
• Begin/End
• If/Then/Else
• For/To/Downto/Do
• Case x Of
• Repeat/Until
• While
• uses
• Exit
• Continue
• Break
• Functions (Declared inside or outside of the script)
• Standard types: Byte, Shortint, Char, Word, SmallInt, Cardinal, Longint, Integer, String, Real, Double, Single, Extended, Boolean, Array, Record, Enumerations, Variant, IUnknown, IDispatch (dynamic invoke)
• Ability to import of Delphi functions and classes
• Assignment of script functions to Delphi events
• Compilation to a file for later use
• Easy to use component version
• Include Files
• Defines
• and much more...

Unlike most other scripting solutions you can use any object, function, or variable you have in your Delphi source within your scripts.

You don't have to generate .TLB's or other kind of import files. This makes working with the RAPWare scripting control as easy as pie.

There is a automatic IDispatch wrapping for all VCL components and it's published properties. Functions are exposed by Invoke wrapper classes.
 
With Nag-Screen
Source: On purchase/registration
Price: $99

By default the Runtime Scripter supports two scripting languages: VBScript interpreter that is Microsoft Visual Basic, Script edition and JScript. These interpreters are provided with operating system.

You can easy add interpreters from other vendors. The Scripter utilizes interpreters that support Active Scripting technology. Such interpreters must support IActiveScript and IActiveScriptParse interfaces. The TScripter can bind an event-handling sub or function to an event associated with a Delphi object without extra coding.

The component suite allows using published events and properties without extra coding. If you need methods just register them.

Features:

• Application Object Model.
  • By default the Application Object Model consists of a parent form and a set of components inserted into it.
• Parameter types.
  • The TScripter component supports passing parameters of following base types:
    • all integers
    • all Boolean
    • all real
    • set
    • TObject and descendant classes
    • interfaces
    • all strings
    • all chars
    • data-time
    • variant.

SXJavaScript interprets ECMAScript of version 3 and JavaScript 1.2 (except Regular Expressions).

The library is well-optimized and has a very high performance.

Lots of programs use their internal languages and interpreters to execute programs, wrote according to those languages:

• JavaScript is interpreted by all web browsers (Firefox, Mozilla, Netscape, Internet Explorer, Opera, etc).
• VBScript can be interpreted by Internet Explorer and all Microsoft Office applications.
• MaxScript is used in 3D Studio MAX.
• ActionScript is used in Macromedia Flash.

SXJavaScript is already used in SXBandMaster Traffic Explorer for TCP/IP Networks. In that program a user can write a script, which will detect whether to dump a packet or not (a script can check sender IP, port and other parameters).
 
Demo only
Source: On purchase/registration
Price: $440
Source Price: $440
Exe-Demo Included

Features:

• Run-time Pascal or Basic language interpreter
• Access any Delphi object in scripts, including properties and methods
• Supports try..except and try..finally blocks in script
• Allows reading/writing of Delphi variables and constants in script
• Allows access (reading/writing) script variables from Delphi code
• You can build (from Delphi code) your own classes, with properties and methods, to be used in script
• Most of Delphi system procedures (conversion, date, formatting, string-manipulation) are already included (IntToStr, FormatDateTime, Copy, Delete, etc.)
• You can add your own custom functions, using AddFunction method
• You can save/load compiled code, so you don't need to recompile source code every time you want to execute it
• Support for libraries of script functions
• Thread-safe scripter engine
• COM support
• Support to call DLL functions
• Script syntax highlighting editor
• Debugging capabilities (breakpoint, step into, run to cursor, pause, halt ...).
• Comes with import files for full VCL library and import tool available for custom VCL libraries
• Pascal and Basic syntax highlighting editor for building lightweight script IDE's
• Greatis Form Designer and Object Inspector interface.

Feature details:

• Integrated Development Environment (IDE) allow creating script projects at runtime with multiple cross-language scripts (Basic and Pascal) and forms
• Visual form designer and Object inspector at runtime
• Integrated and automatic debugging system in the IDE, including breakpoints, watch viewer, trace into libraries, etc.
• Integrated syntax highlight memo with automatic code completion
• Separated components to build your own custom IDE
• Delphi 2007-like filtering system in Tool Palette
• Helper dialogs in IDE like Alignment, Size, Designer options, among others
• Events in IDE components allow saving/loading scripts and forms to/from database
• Run-time Pascal or Basic language interpreter
• Cross-language scripter component allows calls to Basic scripts from Pascal scripts and vice-versa
• Ability to load Delphi dfm forms and run them
• Access any Delphi object in scripts, including properties and methods
• Supports try..except and try..finally blocks in script
• Allows reading/writing of Delphi variables and constants in script
• Allows access (reading/writing) script variables from Delphi code
• You can build (from Delphi code) your own classes, with properties and methods, to be used in script
• Most of Delphi system procedures (conversion, date, formatting, string-manipulation) are already included (IntToStr, FormatDateTime, Copy, Delete, etc.)
• You can add your own custom functions, using AddFunction method
• You can save/load compiled code, so you don't need to recompile source code every time you want to execute it
• Script libraries
• Thread-safe scripter engine
• COM support
• Support for calling DLL functions
• Debugging capabilities (breakpoint, step into, run to cursor, pause, halt ...)

• paxBasic
• paxC
• paxPascal
• paxJavaScript.

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.

XbParser is that interpreter. XbParser based on interpreter and wrapper functions library. This library is designed as a set of XBase commands and functions and provided wrappers for work with databases. You establish connection from your application and further in the scripts, work with the tables using XBase like functions and commands. At the moment you can connect to the database and view tables.
 
Fully functional
Source: None

• The compiler generates machine code for Intel processor.
• It is possible to use the compiler as a scripting engine. You can embed the compiler into host application, register host-defined types, routines, variables and constants for the engine, read/write script-defined variables, call script-defined functions etc. You can save/load compiled scripts to/from a stream.
• The compiler is written in Delphi as a set of Delphi components. TPaxCompiler, TPaxProgram and TPaxPascalLanguage are Delphi components that allows you to embed the paxCompiler into Delphi, Kylix or Borland C++ Builder application so you can customize and extend the application without having to recompile it.
• The compiler implements a subset of Object Pascal language. The supported types are: Boolean, Byte, Word, Integer, Double, Single, Char, AnsiString, ShortString, Pointer, Record Types, Array Types, Subrange Types, Enumeration Types and Procedural Types. The compiler supports such concepts as namespaces, overloaded routines, nested routines, default parameters, units.