8/24/25, 9:39 AM Scripting language - Wikipedia
Scripting language
In computing, a script is a relatively short and simple set of instructions that typically automate
an otherwise manual process. The act of writing a script is called scripting. A scripting
language or script language is a programming language that is used for scripting.[1]
Originally, scripting was limited to automating shells in operating systems, and languages were
relatively simple. Today, scripting is more pervasive and some scripting languages include
modern features that allow them to be used to develop application software also.
GDScript in Godot 3.4
Overview
A scripting language can be a general-purpose programming language or a domain-specific language for a given environment. When
embedded in an application, it may be called an extension language.
A scripting language is sometimes referred to as very high-level programming language if it operates at a high level of abstraction, or as
a control language, especially for job control languages on mainframe computers.
The term scripting language is sometimes used in a wider sense, to refer to dynamic high-level programming languages in general.
Some are strictly interpreted languages, while others use a form of compilation. In this context, the term script refers to a small program
in such a language; typically, contained in a single file, and no larger than a few thousand lines of code.
The scope of scripting languages ranges from small to large, and from highly domain-specific language to general-purpose programming
languages. A language may start as small and highly domain-specific and later develop into a portable and general-purpose language;
conversely, a general-purpose language may later develop special domain-specific dialects.
Notable languages
AWK, for text-processing, generally available in Unix-like operating systems
Bash, interpreted language for scripting Unix and Unix-like operating systems
https://en.wikipedia.org/wiki/Scripting_language 1/10
8/24/25, 9:39 AM Scripting language - Wikipedia
Groovy, Java-like, object-oriented scripting
JavaScript (later: ECMAScript), originally limited to running in a web browser to dynamically modify a web page; later enhanced into
a widely portable, general-purpose programming language
Linden Scripting Language, custom, extension language for scripting Second Life virtual world
Lisp, family of general-purpose and extension languages for applications including Emacs Lisp for Emacs
Lua, extension language used by many applications
Perl,[2] text-processing language that later developed into a general-purpose language; also used as an extension language for
various applications
PowerShell, for scripting Microsoft Windows, macOS and Linux
Python, general-purpose and extension language
Rexx, general-purpose language that runs on many platforms; also used as extension language
Ruby, multiple-paradigm, general-purpose language
sed, for text-processing; available in most Unix-like operating systems and ported to other operating systems
Tcl,[3] for Unix-like environments, popular in the 1990s; can be used in conjunction with Tk to develop GUI applications
TrainzScript, custom, extension language for Trainz railroad simulators
VBScript, for scripting Microsoft Windows
Visual Basic for Applications (VBA), an extension language available in Microsoft Office applications
Batchscript (BAT), for scripting Microsoft Windows
Characteristics
Script is a subjective characterization that generally includes the following attributes.
Interpreted
A script is usually not compiled, at least not its usual meaning. Generally, they are interpreted directly from source code, or from
bytecode, or run as native after just-in-time compilation.[4]
Short & simple
A script is generally relatively short and simple. As there is no limit on size or complexity, script is subjective. A few lines of code without
branching is probably considered a script. A codebase of multiple files, that performs sophisticated user or hardware interface or
complicated algorithms or multiprogramming is probably not considered a script.
https://en.wikipedia.org/wiki/Scripting_language 2/10
8/24/25, 9:39 AM Scripting language - Wikipedia
Automates
A script usually automates a task that would otherwise be performed by a person in a more manual way.
Limited language
A language that is primarily intended for scripting generally has limited capabilities compared to a general-purpose language. A
scripting language may lack the functionality to write complex applications.
Starts at the top
Typically, a script starts executing at the first line of code whereas an application typically starts at a special point in the code called the
entry point.
For example, Java is not script-like since an application starts at the function named main which need not be at the top of the code. The
following code starts at main, then calls printHelloWorld which prints "Hello World".
public class HelloWorld {
public static void printHelloWorld() {
System.out.println("Hello World");
}
public static void main(String[] args) {
printHelloWorld();
}
}
In contrast, the following Python code prints "Hello World" without the main function or other syntax such as a class definition required
by Java.
print("Hello World")
Single user
Scripts are often created or modified by the person executing them,[5] but they are also often distributed, such as when large portions of
games are written in a scripting language, notably the Google Chrome T-rex game.
https://en.wikipedia.org/wiki/Scripting_language 3/10
8/24/25, 9:39 AM Scripting language - Wikipedia
History
Early mainframe computers (in the 1950s) were non-interactive, instead using batch processing. IBM's Job Control Language (JCL) is
the archetype of languages used to control batch processing.[6]
The first interactive shells were developed in the 1960s to enable remote operation of the first time-sharing systems, and these used
shell scripts, which controlled running computer programs within a computer program, the shell. Calvin Mooers in his TRAC language
is generally credited with inventing command substitution, the ability to embed commands in scripts that, when interpreted, insert a
character string into the script.[7] Multics calls these active functions.[8] Louis Pouzin wrote an early processor for command scripts
called RUNCOM for CTSS around 1964. Stuart Madnick at MIT wrote a scripting language for IBM's CP/CMS in 1966. He originally
called this processor COMMAND, later named EXEC.[9] Multics included an offshoot of CTSS RUNCOM, also called RUNCOM.[10]
EXEC was eventually replaced by EXEC 2 and Rexx.
Languages such as Tcl and Lua were specifically designed as general-purpose scripting languages that could be embedded in any
application. Other languages such as Visual Basic for Applications (VBA) provided strong integration with the automation facilities of an
underlying system. Embedding of such general-purpose scripting languages instead of developing a new language for each application
also had obvious benefits, relieving the application developer of the need to code a language translator from scratch and allowing the
user to apply skills learned elsewhere.
Some software incorporates several different scripting languages. Modern web browsers typically provide a language for writing
extensions to the browser itself, and several standard embedded languages for controlling the browser, including JavaScript (a dialect of
ECMAScript) or XUL.
Types
Scripting languages can be categorized into several different types, with a considerable degree of overlap among the types.
Glue languages
Scripting is often contrasted with system programming, as in Ousterhout's dichotomy or "programming in the large and programming
in the small". In this view, scripting is glue code, connecting software components, and a language specialized for this purpose is a glue
language. Pipelines and shell scripting are archetypal examples of glue languages, and Perl was initially developed to fill this same role.
https://en.wikipedia.org/wiki/Scripting_language 4/10
8/24/25, 9:39 AM Scripting language - Wikipedia
Web development can be considered a use of glue languages, interfacing between a database and web server. But if a substantial amount
of logic is written in script, it is better characterized as simply another software component, not "glue".
Glue languages are especially useful for writing and maintaining:
custom commands for a command shell;[11]
smaller programs than those that are better implemented in a compiled language;[12]
"wrapper" programs for executables, like a batch file that moves or manipulates files and does other things with the operating
system before or after running an application like a word processor, spreadsheet, data base, assembler, compiler, etc.;[13]
scripts that may change;[14]
Rapid application development of a solution eventually implemented in another, usually compiled, language.
Glue language examples:
AppleScript Julia Rexx
CoffeeScript Lua NetRexx
ColdFusion m4 Ruby
DCL Perl (5 and Raku) Scheme
ECL PHP Tcl
Embeddable Common Lisp PowerShell Unix shell scripts (ksh, csh, bash, sh
Erlang Pure and others)
EXEC, EXEC2 Python VBScript
JavaScript, JScript Rebol Work Flow Language
Job Control Language (JCL) Red XSLT
Macro languages exposed to operating system or application components can serve as glue languages. These include Visual Basic for
Applications, WordBasic, LotusScript, CorelScript (https://www.oberonplace.com/tutor/page1.htm), Hummingbird Basic, QuickScript,
Rexx, SaxBasic (https://msdn.microsoft.com/en-us/library/ms994312.aspx), and WinWrap Basic. Other tools like AWK can also be
considered glue languages, as can any language implemented by a Windows Script Host engine (VBScript, JScript and VBA by default in
Windows and third-party engines including implementations of Rexx, Perl, Tcl, Python, XSLT, Ruby, Modern Pascal, Delphi, and C). A
majority of applications can access and use operating system components via the object models or its own functions.
Other devices like programmable calculators may also have glue languages; the operating systems of PDAs such as Windows CE may
have available native or third-party macro tools that glue applications together, in addition to implementations of common glue
languages—including Windows NT, DOS, and some Unix shells, Rexx, Modern Pascal, PHP, and Perl. Depending upon the OS version,
WSH and the default script engines (VBScript and JScript) are available.
https://en.wikipedia.org/wiki/Scripting_language 5/10
8/24/25, 9:39 AM Scripting language - Wikipedia
Programmable calculators can be programmed in glue languages in three ways. For example, the Texas Instruments TI-92, by factory
default can be programmed with a command script language. Inclusion of the scripting and glue language Lua in the TI-NSpire series of
calculators could be seen as a successor to this. The primary on-board high-level programming languages of most graphing calculators
(most often Basic variants, sometimes Lisp derivatives, and more uncommonly, C derivatives) in many cases can glue together
calculator functions—such as graphs, lists, matrices, etc. Third-party implementations of more comprehensive Basic version that may be
closer to variants listed as glue languages in this article are available—and attempts to implement Perl, Rexx, or various operating
system shells on the TI and HP graphing calculators are also mentioned. PC-based C cross-compilers for some of the TI and HP
machines used with tools that convert between C and Perl, Rexx, AWK, and shell scripts to Perl, Modern Pascal, VBScript to and from
Perl make it possible to write a program in a glue language for eventual implementation (as a compiled program) on the calculator.
Editor languages
A number of text editors support macros written either using a macro language built into the editor, e.g., The SemWare Editor (TSE), vi
improved (VIM), or using an external implementation, e.g., XEDIT, or both, e.g., KEDIT. Sometimes text editors and edit macros are
used under the covers to provide other applications, e.g., FILELIST and RDRLIST in CMS .
Job control languages and shells
A major class of scripting languages has grown out of the automation of job control, which relates to starting and controlling the
behavior of system programs[15] (in this sense, one might think of shells as being descendants of IBM's JCL, or Job Control Language,
which was used for exactly this purpose). Many of these languages' interpreters double as command-line interpreters such as the Unix
shell or the MS-DOS COMMAND.COM. Others, such as AppleScript offer the use of English-like commands to build scripts.
GUI scripting
With the advent of graphical user interfaces, a specialized kind of scripting language emerged for controlling a computer. These
languages interact with the same graphic windows, menus, buttons, and so on, that a human user would. They do this by simulating the
actions of a user. These languages are typically used to automate user actions. Such languages are also called macros when control is
through simulated key presses or mouse clicks, and tapping or pressing on a touch-activated screen.
These languages could in principle be used to control any GUI application; but, in practice their use is limited because their use needs
support from the application and from the operating system. There are a few exceptions to this limit. Some GUI scripting languages are
based on recognizing graphical objects from their display screen pixels. These GUI scripting languages do not depend on support from
the operating system or application.
https://en.wikipedia.org/wiki/Scripting_language 6/10
8/24/25, 9:39 AM Scripting language - Wikipedia
When the GUI provides the appropriate interfaces, as in the IBM Workplace Shell, a generic scripting language, e.g., Object REXX, can
be used to write GUI scripts.
Application-specific languages
Application specific languages can be split in many different categories, i.e., standalone based app languages (executable) or internal
application specific languages (Postscript, XML, gscript as some of the widely distributed scripts, respectively implemented by Adobe,
Microsoft and Google) among others include an idiomatic scripting language tailored to the needs of the application user. Likewise,
many computer game systems use a custom scripting language to express the programmed actions of non-player characters and the
game environment. Languages of this sort are designed for a single application; and, while they may superficially resemble a specific
general-purpose language (e.g., QuakeC, modeled after C), they have custom features that distinguish them. Emacs Lisp, while a fully
formed and capable dialect of Lisp, contains many special features that make it most useful for extending the editing functions of
Emacs. An application-specific scripting language can be viewed as a domain-specific programming language specialized to one
application.
Extension/embeddable languages
A number of languages have been designed for the purpose of replacing application-specific scripting languages by being embeddable in
application programs. The application programmer (working in C or another systems language) includes "hooks" where the scripting
language can control the application. These languages may be technically equivalent to an application-specific extension language but
when an application embeds a "common" language, the user gets the advantage of being able to transfer skills from application to
application. A more generic alternative is simply to provide a library (often a C library) that a general-purpose language can use to
control the application, without modifying the language for the specific domain.
JavaScript began as, and still is mostly, a language for scripting inside web browsers. However, the standardizing of the language as
ECMAScript has made it popular as a general-purpose embeddable language. The Mozilla implementation SpiderMonkey is embedded
in several environments such as the Yahoo Widgets Engine,and applications such as the Adobe products Flash (ActionScript) and
Acrobat (for scripting PDF files).
Tcl was created as an extension language but has come to be used more often as a general-purpose language in roles similar to Python,
Perl, and Ruby. In contrast, Rexx was created as a job control language, but is widely used as an extension language and a general-
purpose language. Perl is a general-purpose language, but had the Oraperl (1990) dialect, consisting of a Perl 4 binary with Oracle Call
Interface compiled in. This has however since been replaced by a library (Perl Module), DBD::Oracle (https://metacpan.org/module/D
BD::Oracle).[16][17]
https://en.wikipedia.org/wiki/Scripting_language 7/10
8/24/25, 9:39 AM Scripting language - Wikipedia
Other complex and task-oriented applications may incorporate and expose an embedded programming language to allow their users
more control and give them more functionality than can be available through a user interface, no matter how sophisticated. For
example, Autodesk Maya 3D authoring tools embed the Maya Embedded Language, or Blender which uses Python to fill this role.
Some other types of applications that need faster feature addition or tweak-and-run cycles (e.g. game engines) also use an embedded
language. During the development, this allows them to prototype features faster and tweak more freely, without the need for the user to
have intimate knowledge of the inner workings of the application or to rebuild it after each tweak (which can take a significant amount
of time). The scripting languages used for this purpose range from the more common and more famous Lua and Python to lesser-known
ones such as AngelScript and Squirrel.
See also
Architecture description language
Authoring language
Build automation[18]
Configuration file
Interpreter directive, Shebang (Unix)
Templating language
References
1. "ECMAScript 2019 Language Specification" (https://tc39.github.io/ecma262/#sec-overview). Ecma International. Retrieved
2018-04-02.
2. Sheppard, Doug (2000-10-16). "Beginner's Introduction to Perl" (http://www.perl.com/pub/2000/10/begperl1.html). Perl.com.
Retrieved 2011-01-08.
3. Wall, Larry (2007-12-12). "Programming is Hard, Let's Go Scripting" (http://www.perl.com/pub/2007/12/06/soto-11.html). Perl.com.
Archived (https://web.archive.org/web/20231208163227/https://www.perl.com/pub/2007/12/06/soto-11.html/) from the original on
December 8, 2023.
4. Brown, Vicki; Morin, Rich (1999). "Scripting Languages" (http://www.mactech.com/articles/mactech/Vol.15/15.09/ScriptingLanguage
s/). MacTech. Retrieved 2009-07-22.
5. Loui, Ronald. "In Praise of Scripting: Real Programming Pragmatism" (https://web.archive.org/web/20150923211452/http://www.cse.
wustl.edu/~loui/praiseieee.html). IEEE Computer. Archived from the original (http://www.cse.wustl.edu/~loui/praiseieee.html) on
2015-09-23. Retrieved 2013-08-27.
https://en.wikipedia.org/wiki/Scripting_language 8/10
8/24/25, 9:39 AM Scripting language - Wikipedia
6. IBM Corporation (March 1967). IBM System/360 Operating System Job Control Language (C28-6529-4) (http://www.bitsavers.org/p
df/ibm/360/os/R01-08/C28-6539-4_OS_JCL_Mar67.pdf) (PDF). Archived (https://web.archive.org/web/20230525192103/http://www.
bitsavers.org/pdf/ibm/360/os/R01-08/C28-6539-4_OS_JCL_Mar67.pdf) (PDF) from the original on May 25, 2023 – via bitsavers.
7. Mooers, Calvin (1965). "TRAC, A Procedure-Describing Language for the Reactive Typewriter" (https://web.archive.org/web/200104
25014914/http://tracfoundation.org/trac64/procedure.htm). TRAC Foundation. Archived from the original (http://tracfoundation.org/tra
c64/procedure.htm) on 2001-04-25. Retrieved March 9, 2012.
8. Van Vleck, Thomas (ed.). "Multics Glossary – A — (active function)" (http://www.multicians.org/mga.html). Multics. Retrieved
March 9, 2012.
9. Varian, Melinda (April 1991). "VM and the VM Community: Past, Present, and Future" (https://web.archive.org/web/2011100606470
1/http://web.me.com/melinda.varian/Site/Melinda_Varians_Home_Page_files/neuvm.pdf) (PDF). Archived from the original (http://we
b.me.com/melinda.varian/Site/Melinda_Varians_Home_Page_files/neuvm.pdf) (PDF) on October 6, 2011. Retrieved March 9, 2012.
10. Van Vleck, Thomas (ed.). "Multics Glossary – R — (RUNCOM)" (http://www.multicians.org/mgr.html#runcom). Retrieved March 9,
2012.
11. "What is glue code (glue code language)? - Definition from WhatIs.com" (https://whatis.techtarget.com/definition/glue-code).
WhatIs.com. Retrieved 2022-01-31.
12. Larson, Quincy (10 January 2020). "Interpreted vs Compiled Programming Languages" (https://www.freecodecamp.org/news/compil
ed-versus-interpreted-languages/). Free Code Camp. Retrieved 23 February 2022.
13. Balkis, Anton. "Script Adalah" (https://rajatips.com/script/). Raja Tips. Retrieved 23 February 2022.
14. Axelsson, Mats. "Shell scripts - What can you change" (https://linuxhint.com/customize_shell_scripts/). Linux Hint. Retrieved
23 February 2022.
15. "Job Control Basics (Bash Reference Manual)" (https://www.gnu.org/software/bash/manual/html_node/Job-Control-Basics.html).
GNU. Retrieved 2022-05-20.
16. "Oraperl - [Deprecated (https://metacpan.org/module/Oraperl) Perl access to Oracle databases for old oraperl scripts]", metacpan.
17. "Perl (http://www.orafaq.com/wiki/Perl)", Underground Oracle FAQ.
18. van Rossum, Guido (January 6–8, 1998). "Glue It All Together With Python" (https://www.python.org/doc/essays/omg-darpa-mcc-po
sition/). Python.org. Archived (https://web.archive.org/web/20240119041124/https://www.python.org/doc/essays/omg-darpa-mcc-pos
ition/) from the original on January 19, 2024.
Further reading
Barron, David William (2001). The World of Scripting Languages. Wiley. ISBN 0-471-99886-9.
https://en.wikipedia.org/wiki/Scripting_language 9/10
8/24/25, 9:39 AM Scripting language - Wikipedia
External links
Patterns for Scripted Applications (https://web.archive.org/web/20041010125419/http://www.doc.ic.ac.uk/~np2/patterns/scripting/) at
the Wayback Machine (archived October 10, 2004)
Retrieved from "https://en.wikipedia.org/w/index.php?title=Scripting_language&oldid=1305417363"
https://en.wikipedia.org/wiki/Scripting_language 10/10
