# Forth

> programming language

**Wikidata**: [Q275472](https://www.wikidata.org/wiki/Q275472)  
**Wikipedia**: [English](https://en.wikipedia.org/wiki/Forth_(programming_language))  
**Source**: https://4ort.xyz/entity/forth

## Summary
Forth is a stack-oriented, concatenative programming language created by Charles H. Moore in 1970. It is typeless, supports procedural and reflective programming paradigms, and has both interpreted and compiled implementations.

## Key Facts
- Forth was created and designed by Charles H. Moore; Moore was born 1938-09-09.  
- Inception year: 1970.  
- Forth is classified as a programming language and as an interpreted language; it is also implemented as a compiled language.  
- Primary programming paradigms: procedural, stack-oriented programming, reflective programming, and concatenative programming.  
- Typing discipline: typeless.  
- Influenced by Lisp, APL, and Burroughs large systems.  
- Official standard website: https://forth-standard.org/ (English).  
- Common file extensions: .fth (Pforth), .fs (Gforth), .4th (The Forth Net), .fb (Gforth; fixed width text file), .f, .forth.  
- Community and ecosystem identifiers: subreddit "Forth", GitHub topic "forth", Wikipedia title "Forth (programming language)".  
- Notable external example: Hypergate (1988) was written in FORTH for the Macintosh operating system.

## FAQs
### Q: What is Forth?
A: Forth is a stack-oriented, concatenative programming language created by Charles H. Moore in 1970. It is typeless and supports procedural and reflective programming, with both interpreted and compiled implementations.

### Q: Who created Forth and when?
A: Forth was created and designed by Charles H. Moore; the language's inception date is recorded as 1970. Charles H. Moore was born on 1938-09-09.

### Q: Is Forth compiled or interpreted?
A: Forth is implemented in both ways: it is classified as an interpreted language and also has compiled implementations. Both execution approaches are used in different Forth systems.

### Q: What programming paradigms does Forth use?
A: Forth uses procedural, stack-oriented, reflective, and concatenative programming paradigms and is typeless in its typing discipline.

### Q: Where can I find the Forth standard or community resources?
A: The official standard site is https://forth-standard.org/. Community resources include a "Forth" subreddit and a GitHub topic "forth"; documentation and summaries are available on sites like Esolang and Wikipedia ("Forth (programming language)").

## Why It Matters
Forth matters because it embodies a distinctive combination of language design choices that influenced niche areas of programming and tool building. Its concatenative, stack-oriented model departs from conventional expression-based languages and enables concise, low-level control over execution and data flow. The language's typeless discipline and reflective features make it adaptable for building domain-specific dialects and extending the language from within programs. Forth's flexibility led to numerous independent implementations and file-format conventions (for example, Pforth and Gforth extensions), and it served as a practical choice for systems and tools that required compact, extensible runtimes—illustrated by applications such as the Hypergate hypertext system (1988) written in FORTH. The language's lineage (influenced by Lisp, APL, and Burroughs large systems) situates it historically among experimental and pragmatic languages of the late 20th century, and ongoing standards and communities preserve its use and evolution.

## Notable For
- Being created and designed by Charles H. Moore in 1970.  
- A concatenative, stack-oriented, and typeless design that differs from mainstream expression-oriented languages.  
- Supporting both interpreted and compiled implementations, allowing varied deployment models.  
- Influence from Lisp, APL, and Burroughs large systems, reflecting a mix of functional and systems-oriented ideas.  
- Multiple community and implementation identifiers (Pforth, Gforth, The Forth Net) and a formal standard site at forth-standard.org.

## Body
### Overview
- Name: Forth (also stylized FORTH; aliases: FORTH, Forth编程语言, Forth语言).  
- Core description: a programming language that is stack-oriented and concatenative.  
- Typing: typeless.  
- Paradigms: procedural programming, stack-oriented programming, reflective programming, concatenative programming.

### History and Origins
- Inception: 1970.  
- Designed and developed by Charles H. Moore (born 1938-09-09).  
- The language evolved through multiple implementations and community variants.

### Design and Paradigms
- Stack-oriented: computation primarily manipulates a data stack.  
- Concatenative: programs are composed by concatenating words (functions) that operate on the stack.  
- Reflective: language facilities allow programs to inspect or modify their own structure or behavior.  
- Procedural: supports structured sequences of commands and control flow.  
- Typeless: the language does not enforce static typing disciplines.

### Implementations and Formats
- Classified as both an interpreted language and a compiled language; different Forth systems use interpretation, compilation, or a mixture.  
- Common implementations and related tools include Pforth and Gforth (indicated by file-extension qualifiers).  
- File extensions used in the Forth ecosystem include:  
  - .fth (Pforth)  
  - .fs (Gforth)  
  - .4th (The Forth Net)  
  - .fb (Gforth; fixed width text file)  
  - .f  
  - .forth

### Influence and Use Cases
- Influenced by Lisp, APL, and Burroughs large systems.  
- Example application: Hypergate (1988), an early hypertext system for the Macintosh, was written in FORTH.

### Standards, Documentation, and Community
- Official standard website: https://forth-standard.org/ (English).  
- Documented or summarized on Esolang (page titled "Forth") and on Wikipedia under "Forth (programming language)".  
- Community presence: subreddit "Forth", GitHub topic "forth".

### Identifiers and Cataloging
- GND ID: 4017981-3.  
- Freebase ID: /m/02z81.  
- Dewey Decimal Classification: 005.133.  
- Library of Congress authority ID: sh85050918.  
- National Library of Israel J9U ID: 987007545715805171.  
- Wikidata item: Q328 (see sameAs in schema).

## Schema Markup
```json
{
  "@context": "https://schema.org",
  "@type": "Thing",
  "name": "Forth",
  "description": "Forth is a stack-oriented, concatenative programming language created by Charles H. Moore in 1970; it is typeless and supports procedural and reflective paradigms with interpreted and compiled implementations.",
  "url": "https://forth-standard.org/",
  "sameAs": [
    "https://www.wikidata.org/wiki/Q328",
    "https://en.wikipedia.org/wiki/Forth_(programming_language)"
  ],
  "additionalType": "ProgrammingLanguage"
}

## References

1. [Source](https://lingualibre.fr/wiki/Q201046)
2. Freebase Data Dumps. 2013
3. Integrated Authority File
4. National Library of Israel Names and Subjects Authority File