# scripting language

> programming language for run-time events

**Wikidata**: [Q187432](https://www.wikidata.org/wiki/Q187432)  
**Wikipedia**: [English](https://en.wikipedia.org/wiki/Scripting_language)  
**Source**: https://4ort.xyz/entity/scripting-language

## Summary
A scripting language is a programming language designed for runtime events, enabling rapid development and execution of scripts that automate tasks or interact with software at runtime. It prioritizes ease of use and flexibility over raw performance, often used for automation, system configuration, and integrating disparate applications. Scripting languages are typically interpreted rather than compiled, allowing for immediate execution.

## Key Facts
- **Primary Use**: Computer configuration, automation, and runtime event handling.
- **Classification**: Subclass of programming language; opposite of systems programming language.
- **Notable Examples**: AppleScript (1993), Squirrel (2003), Hyperscript (2020), Lua-based Luau, and JavaScript-based njs.
- **Aliases**: Script language, glue language, embeddable language.
- **Wikidata Sitelink Count**: 56 (indicating broad multilingual coverage).
- **Key Properties**: Interpreted execution, dynamic typing, and embeddability in host applications.

## FAQs
### Q: How does a scripting language differ from a systems programming language?
A: Scripting languages prioritize ease of use and runtime execution for automation and integration, while systems programming languages focus on direct hardware control and performance.

### Q: What are common use cases for scripting languages?
A: They are used for automating tasks (e.g., build processes with Starlark), configuring software, and creating interactive content (e.g., visual novels with dedicated engines).

### Q: Are scripting languages always interpreted?
A: Most are interpreted for rapid development, but some may be compiled (e.g., Amber to Bash) while retaining scripting characteristics.

## Why It Matters
Scripting languages democratize automation and customization, enabling users to extend software capabilities without deep programming expertise. They accelerate workflows in domains like web development (Hyperscript), game design (Ink), and system administration (KiXtart). By bridging applications and simplifying task execution, scripting languages reduce development overhead and foster interoperability, playing a critical role in DevOps, scientific computing, and content creation.

## Notable For
- **Interpreted Execution**: Enables runtime evaluation and dynamic behavior.
- **Domain-Specific Applications**: Used in unique contexts like Second Life (Linden Scripting Language) and GIMP (Script-Fu).
- **Lightweight Design**: Prioritizes simplicity and ease of embedding (e.g., AiScript, ChavaScript).
- **Historical Significance**: Early tools like AppleScript (1993) and Emacs Lisp (1985) pioneered automation in consumer and professional software.

## Body
### Technical Characteristics
- **Interpreted vs. Compiled**: Most scripting languages are interpreted (e.g., JavaScript for Automation), though exceptions exist (e.g., Amber compiles to Bash).
- **Dynamic Typing**: Common in scripting languages for flexibility (e.g., Lua, Python).
- **Embeddability**: Designed to integrate with host applications (e.g., Lua in game engines, Tcl in CAD software).

### Development and History
- **Early Tools**: Emacs Lisp (1985) and AppleScript (1993) established scripting for customization and automation.
- **Modern Innovations**: Hyperscript (2020) reflects web-centric needs, while Squirrel (2003) targets embedded systems.
- **Specialized Languages**: Domain-specific tools like JASS (2001) for game modding and SassScript for CSS preprocessing.

### Applications and Examples
- **Web Development**: Hyperscript, njs (JavaScript-based), and Server-Side Includes.
- **Game Development**: Luau (Lua-based), Ink (narrative design), and Linden Scripting Language.
- **System Administration**: KiXtart (logon scripts), PowerShell (not listed but implied in context), and Bash scripting.

## Schema Markup
```json
{
  "@context": "https://schema.org",
  "@type": "Thing",
  "name": "Scripting language",
  "description": "Programming language for run-time events",
  "url": "https://en.wikipedia.org/wiki/Scripting_language",
  "sameAs": [
    "https://www.wikidata.org/wiki/Q262455",
    "https://en.wikipedia.org/wiki/Scripting_language"
  ],
  "additionalType": "ProgrammingLanguage",
  "keywords": ["Automation", "Interpreted Language", "Dynamic Typing"]
}

## References

1. [Source](https://github.com/JohnMarkOckerbloom/ftl/blob/master/data/wikimap)
2. Freebase Data Dumps. 2013
3. National Library of Israel
4. [OpenAlex](https://docs.openalex.org/download-snapshot/snapshot-data-format)