pldb/PLDB huggingface dataset:
Texy! (textMarkup, appeared 2004)
Website: https://texy.info/


Texy is a lightweight markup language as well as converter of this format to XHTML, in a form of a library written in the PHP scripting language. It allows the user to write structured documents without knowledge or using of HTML language. Users write documents in human-readable text format and Texy converts it to structurally valid and well-formed XHTML code. Texy! format includes tags for turning off the formatter as well as for direct CSS styling, thus it can be said it fully supports HTML and CSS. The format itself supports images, links (anchors), nested lists, and tables, among other things. Other built-in features include a support of long words division (with respect for language rules), roll-over images, clickable emails and URL (emails are obfuscated against spambots), and an auto-correct tool for several typographic issues: national single and double quotation marks, ellipses, em dashes, dimension sign, nonbreakable spaces (e.g. in phone numbers), acronyms, arrows and many others. PHP implementation of Texy has been developed by David Grudl since 2004. It runs on PHP version 4.3.3 or newer and it can be used in any other platform using XML/RPC service. Current stable version is 2.9. Version 3.0 is planned. Texy! is distributed under the GNU General Public License and New BSD License. Plugins for several content-management systems are included. Java implementation, named JTexy, is under development. The project has its own website with basic description, syntax overview, on-line demo, XMLRPC, forum. Support for English-speaking users could be described as poor.
THEOS (pl, appeared 1977)


THEOS, which translates from Greek as "God", is an operating system which started out as OASIS, a microcomputer operating system for small computers that use the Z80 processor. Originally written in the late 1970s by Timothy S. Williams as a low-cost alternative to the more expensive mini- and mainframe- computers that were popular in the day, OASIS provided time-sharing multiuser facilities to allow several users to utilise the resources of one computer. Similar in concept to MP/M or UNIX, THEOS uses external device drivers rather than a kernel, allowing it to be more portable to other environments, though support has been primarily directed towards industry-standard hardware (i.e. PC's).  THEOS is specifically aimed at small business users, with a wide range of vertical-market applications packages being developed and supported by individuals and companies. THEOS operating systems have been distributed by THEOS Software Corporation in Walnut Creek, California, since 1983. As of 2003, Phase One Systems publishes software development tools for THEOS(R) systems. As well as porting tools, Phase One Systems distributed the Freedom query package and Control database package for THEOS systems, used to bring SQL-like data extraction tools to third-party software packages. The languages distributed with THEOS include THEOS Multi-User Basic and C. A powerful EXEC shell language can be used for task automation or to produce a turnkey system. When the operating system was launched for the IBM Personal Computer/AT in 1982, the decision was taken to change the name from OASIS to THEOS, short for THE Operating System. A number of security features exist, including dynamic passwords (where the password includes part of the date or time, or client IP address, or other dynamic elements), allow/deny security, a comprehensive inbound and outbound firewall, and an option to require a certain level of encryption in the workstation connection. In addition, the object file format is proprietary, and the operating system uses Intel "protected mode" to further increase defence against buffer overrun attacks. THEOS was introduced in Europe by Fujitsu and other hardware manufacturers 30 years ago, and is distributed by a number of distributors in Great Britain, Spain, Portugal, Germany, Italy and more. The 'current' version is THEOS Corona Commercial Release 6, which was released in December 2008, and a number of updates have been released since that time. The current Windows Workstation Client (as of May 2009) is version 3.16 from July 2003.
ThingLab (pl, appeared 1979)


ThingLab is a visual programming environment implemented in Smalltalk and designed at Xerox PARC by Alan Borning. A conventional system allows a user to provide inputs that produce outputs.  A constraint-oriented system, such as ThingLab, allows the user to provide arbitrary inputs or outputs, then solves for whatever is unknown. ThingLab is viewed as one of the earliest constraint-oriented systems.ThingLab is credited in "Fumbling the Future" as a big reason Xerox continued to fund computer development.
THINK C (pl, appeared 1986)


THINK C was an extension of ANSI C for the classic Mac OS developed by THINK Technologies; although named Lightspeed C in the original mid-1986 release, it was later renamed THINK C. THINK Technologies was later acquired by Symantec Corporation and the product continued to be developed by the original author, Michael Kahl. Version 3 and subsequent versions were essentially a subset of C++ and supported basic object oriented programming concepts such as single inheritance as well as extensions to the C standard that conformed more closely to the requirements of Mac OS programming. After version 6, the OOP facilities were expanded to a full C++ implementation, and the product was rebranded Symantec C++ for versions 7 and 8, now under development by different authors. THINK C (and later, Symantec C++) featured a class library and framework for Mac programming called the Think Class Library (TCL), which was used extensively for Macintosh application development. The Lightspeed/THINK C IDE was quite influential, though considered not as advanced as that belonging to THINK Pascal, its sister language product; it was considered the standard environment when MPW was considered an overpriced niche product, and most Macintosh products were developed in it for many years. With the transition of the Mac from 68K to PowerPC, however, Symantec was widely seen as having dropped the ball, and competitor Metrowerks's product CodeWarrior took control of the marketplace. Despite the decline in popularity of their IDE, Symantec was eventually chosen by Apple to provide next-generation C/C++ compilers for MPW in the form of Sc/Scpp for 68K alongside MrC/MrCpp for PowerPC. These remained Apple's standard compilers until the arrival of Mac OS X replaced them with GCC. Symantec subsequently exited the developer tool business.
Thrift (idl, appeared 2007)
Origin: Apache
Website: http://thrift.apache.org/


Thrift is an interface definition language and binary communication protocol that is used to define and create services for numerous languages. It is used as a remote procedure call (RPC) framework and was developed at Facebook for "scalable cross-language services development". It combines a software stack with a code generation engine to build cross-platform services that can connect applications written in a variety of languages and frameworks, including ActionScript, C, C++, C#, Cappuccino, Cocoa, Delphi, Erlang, Go, Haskell, Java, Node.js, Objective-C, OCaml, Perl, PHP, Python, Ruby and Smalltalk. Although developed at Facebook, it is now an open source project in the Apache Software Foundation. The implementation was described in an April 2007 technical paper released by Facebook, now hosted on Apache.


enum PhoneType {
 HOME,
 WORK,
 MOBILE,
 OTHER
}

struct Phone {
  1: i32 id,
  2: string number,
  3: PhoneType type
}

service PhoneSvc {
  Phone findById(1: i32 id),
  list<Phone> findAll()
}
tht (pl, appeared 2017)
Website: https://tht-lang.org/



GitHub description: THT Programming Language

// Familiar variable and List syntax.
$colors = ['red', 'blue', 'green'];
// New JSON-style syntax for Maps
$colorHex = {
    red:   '#FF0000',
    green: '#00FF00',
    blue:  '#0000FF',
};
// Built-in types have methods using
// the mainstream 'dot' syntax.
$colors.push('purple');
// Extra parens aren't needed.
if $colors.length() > 3 {
    $colors.pop();
}
// The standard library is organized
// into modules.
Response.sendPage({
    title: 'Colors',
    body: bodyHtml($colors),
});
// Template Functions let you organize
// your output (views) however you like.
// (e.g. by component, module, file, etc.)
template bodyHtml($colors) {
    <h1>Colors</>
    <ul>
    -- foreach $colors as $c {
        <li>{{ $c.toUpperCaseFirst() }}</>
    -- }
    </>
}
Thue (esolang, appeared 2004)


Thue ( TOO-ay) is an esoteric programming language invented by John Colagioia in early 2000. It is a meta-language that can be used to define or recognize Type-0 languages from the Chomsky hierarchy. Because it is able to define languages of such complexity, it is also Turing-complete itself. Thue is based on a nondeterministic string rewriting system called semi-Thue grammar, which itself is named after the Norwegian mathematician Axel Thue. The author describes it as follows: "Thue represents one of the simplest possible ways to construe constraint-based programming. It is to the constraint-based paradigm what languages like OISC are to the imperative paradigm; in other words, it's a tar pit."
Thymeleaf (template, appeared 2011)


Thymeleaf is a Java XML/XHTML/HTML5 template engine that can work both in web (servlet-based) and non-web environments. It is better suited for serving XHTML/HTML5 at the view layer of MVC-based web applications, but it can process any XML file even in offline environments. It provides full Spring Framework integration. In web applications Thymeleaf aims to be a complete substitute for JavaServer Pages (JSP), and implements the concept of Natural Templates: template files that can be directly opened in browsers and that still display correctly as web pages. Thymeleaf is Open-Source Software, licensed under the Apache License 2.0.
TI Program (assembly, appeared 1970)




.AlphaCS
#ExprOff
If getKey(41)
	sub(ADM)
End
Lbl START
"appv alpha "->Str1
"appvAlphaCS"->Str2
.ALPHA CS
[7EFFFFE7FFFFE7E7]->Pic11
[E0E0E0E0E0FFFF7F]->Pic12
[FEFFE7FFFEE0E0E0]->Pic13
[E7E7E7FFFFE7E7E7]->Pic14
[7EFFFFE7FFFFE7E7]->Pic15
[7FFFFFE0E0FFFF7F]->Pic16
[7FFFFF781EFFFFFE]->Pic17
.arch
[0038447C44440000]->Pic21
.hide
[0054004400540000]->Pic22
.lock
[0038447C7C7C0000]->Pic23
.(c) Scott Mangiapane
Data(72,8)->GDB0
[42600A360008000100994DDF2A6C61B1B28091294A22AAAAAAAB005A6DCA226A69B9A9800000000000202000000000000000C0200000000000000000000000000000000000000000]
.icon unknown
Data(16,16)->GDB11
[EFFEA803EB8308032BFB28032BFB0803EBFBA803EBFB08032B8328032FFF07FF]
.icon SRC
Data(16,16)->GDB12
[01801A583E7C3FFC3FFC3E7C1A580A500240FFFFC471BDAFCC6FF5AF8DB1FFFF]
.icon ASM
Data(16,16)->GDB13
[FFFFFFFFFFFFFFFFFFFFCE6BB5D586D5B75DB4DDFFFFFFFFFFFFFFFFFFFFFFFF]
.icon shell
Data(16,16)->GDB14
[FFFFFFFFFFFFFFFFFFFFFFFF97B5B155D5359595FFFFFFFFFFFFFFFFFFFFFFFF]
Goto SET
prgmSRCFUNC
prgmSRCGUI
prgmSRCSORT
Lbl SET
.start, set up
ClrDraw
StoreGDB 
DiagnosticOff
Fix 5
Full
!If GetCalc(Str1,[Y1])
	sub(NEW)
	StoreGDB 
End
GetCalc(Str1,[Y1])
If {[Y1]+0}
	!If sub(CODE)
		Goto END
	End
End
Asm(FDCB249E)
If {[Y1]+6}
	Asm(FDCB24DE)
End
Goto DLIST
TI-BASIC (pl, appeared 1970)


TI-BASIC is the official name of a BASIC-like language built into Texas Instruments (TI)'s graphing calculators, including the TI-83 series, TI-84 Plus series, TI-89 series, TI-92 series (including Voyage 200), TI-73, and TI-Nspire. TI rarely refers to the language by name, but the name TI-BASIC has been used in some developer documentation. For many applications, it is the most convenient way to program any TI calculator, since the capability to write programs in TI-BASIC is built-in. Assembly language (often referred to as "asm") can also be used, and C compilers exist for translation into assembly: TIGCC for Motorola 68000 (68k) based calculators, and SDCC for Zilog Z80 based calculators. However, both of them are cross-compilers, not allowing on-calculator programming. TI-BASIC is considerably slower than the assembly language (because it has to be interpreted), making it better suited to writing programs to quickly solve math problems or perform repetitive tasks, rather than programming games or graphics-intensive applications. Some math instruction books even provide programs in TI-BASIC (usually for the widespread variant used by the TI-82/83/84 series). Although it is somewhat minimalist compared to programming languages used on computers, TI-BASIC is nonetheless an important factor in the programming community. Because TI graphing calculators are required for advanced mathematics classes in many high schools and universities, TI-BASIC often provides the first glimpse many students have into the world of programming.
Tagged Image File Format (binaryDataFormat, appeared 1986)
Stands for: Tagged Image File Format


Tagged Image File Format, abbreviated TIFF or TIF, is a computer file format for storing raster graphics images, popular among graphic artists, the publishing industry, and photographers. TIFF is widely supported by scanning, faxing, word processing, optical character recognition, image manipulation, desktop publishing, and page-layout applications. The format was created by Aldus Corporation for use in desktop publishing. It published the latest version 6.0 in 1992, subsequently updated with an Adobe Systems copyright after the latter acquired Aldus in 1994. Several Aldus or Adobe technical notes have been published with minor extensions to the format, and several specifications have been based on TIFF 6.0, including TIFF/EP (ISO 12234-2), TIFF/IT (ISO 12639), TIFF-F (RFC 2306) and TIFF-FX (RFC 3949).
Tiny BASIC (pl, appeared 1975)
Creators: Dennis Allison


Tiny BASIC is a dialect of the BASIC programming language that can fit into as little as 2 or 3 KB of memory. This small size made it invaluable in the early days of microcomputers in the mid-1970s, when typical memory size was only 4 to 8 KB. To meet these strict size limits, math was purely integer based and it lacked arrays. The language was written, in part, as an alternative to Microsoft BASIC. MS BASIC would also run in 4 KB machines, but left only 790 bytes free for the programs. More free space was a significant advantage of Tiny BASIC. Piracy of MS BASIC led Bill Gates to publish an open letter complaining about people "stealing" BASIC, which further helped drive the popularity of this alternative. Tiny BASIC was published in a newsletter offshoot of the People's Computer Company. Dozens of versions were created for almost every platform of the era, and there were many variations and additions that were published over time. The newsletter eventually became Dr. Dobb's Journal, a long-lived computing magazine. Tiny BASIC is an example of a free software project that existed before the free software movement.
Tiny C Compiler (compiler, appeared 2001)
Also known as: TCC TinyCC
Website: http://bellard.org/tcc/


The Tiny C Compiler (a.k.a. TCC, tCc, or TinyCC) is an x86, X86-64 and ARM processor C compiler created by Fabrice Bellard. It is designed to work for slow computers with little disk space (e.g. on rescue disks). Windows operating system support was added in version 0.9.23 (17 Jun 2005). TCC is distributed under the GNU Lesser General Public License (LGPL). TCC claims to implement all of ANSI C (C89/C90), much of the C99 ISO standard, and many GNU C extensions including inline assembly.

GitHub description: Unofficial mirror of mob development branch
TIScript (pl, appeared 2007)
Creators: Andrew Fedoniouk
Origin: Terra Informatica Software
Country: Canada
Website: https://sciter.com/developers/for-web-programmers/tiscript-vs-javascript/
Keywords: catch
class
const
else
false
finally
for
function
get
if
in
instanceof
namespace
new
null
property
return
set
super
this
throw
true
try
typeof
undefined
var
Timeless Instruction Set (TL ISA) (isa, appeared 2022)
Origin: Inductive AS
Country: Norway

An ISA for timeless programs. It aims to be simple, concise and powerful. It is easy to read and write by humans. In addition to supporting computations, it also natively supports multiple CPUs, disks, clocks, screens, audio, keyboards and virtual devices. It is a compilation target for the progsbase programming language.
TLA (pl, appeared 1999)
Creators: Leslie Lamport

TLA+ is a formal specification and verification language that helps engineers design, specify, reason about and verify complex, real-life algorithms and software or hardware systems. TLA+ has been successfully used by Intel, Compaq and Microsoft in the design of hardware systems, and has started seeing recent use in large software systems, at Microsoft, Oracle, and most famously at Amazon, where engineers use TLA+ to specify and verify many AWS services.

TLA+ (pronounced as tee ell a plus, ) is a formal specification language developed by Leslie Lamport. It is used to design, model, document, and verify concurrent systems. TLA+ has been described as exhaustively-testable pseudocode, and its use likened to drawing blueprints for software systems; TLA is an acronym for Temporal Logic of Actions. For design and documentation, TLA+ fulfills the same purpose as informal technical specifications. However, TLA+ specifications are written in a formal language of logic and mathematics, and the precision of specifications written in this language is intended to uncover design flaws before system implementation is underway.Since TLA+ specifications are written in a formal language, they are amenable to finite model checking. The model checker finds all possible system behaviours up to some number of execution steps, and examines them for violations of desired invariance properties such as safety and liveness. TLA+ specifications use basic set theory to define safety (bad things won't happen) and temporal logic to define liveness (good things eventually happen). TLA+ is also used to write machine-checked proofs of correctness both for algorithms and mathematical theorems. The proofs are written in a declarative, hierarchical style independent of any single theorem prover backend. Both formal and informal structured mathematical proofs can be written in TLA+; the language is similar to LaTeX, and tools exist to translate TLA+ specifications to LaTeX documents.TLA+ was introduced in 1999, following several decades of research into a verification method for concurrent systems. A toolchain has since developed, including an IDE and distributed model checker. The pseudocode-like language PlusCal was created in 2009; it transpiles to TLA+ and is useful for specifying sequential algorithms. TLA+2 was announced in 2014, expanding language support for proof constructs. The current TLA+ reference is The TLA+ Hyperbook by Leslie Lamport.
TMG (grammarLanguage, appeared 1968)
Creators: Robert M. McClure


TMG (TransMoGrifier) is a compiler-compiler created by Robert M. McClure and presented in 1968, and implemented by Douglas McIlroy. TMG ran on systems like OS360 and early Unix. It was used to build EPL, an early version of PL/I. Ken Thompson used TMG in 1970 on PDP-7 as a tool to offer Fortran, but ended up creating the B programming language which was much influenced by BCPL.
TextMate Language (grammarLanguage, appeared 2004)
Website: https://macromates.com/manual/en/language_grammars
File extensions: tmLanguage




scopeName = 'source.untitled';
fileTypes = ( );
foldingStartMarker = '\{\s*$';
foldingStopMarker = '^\s*\}';
patterns = (
   {  name = 'keyword.control.untitled';
      match = '\b(if|while|for|return)\b';
   },
   {  name = 'string.quoted.double.untitled';
      begin = '"';
      end = '"';
      patterns = ( 
         {  name = 'constant.character.escape.untitled';
            match = '\\.';
         }
      );
   },
);
toadskin (esolang, appeared 2003)
Website: http://freshmeat.sourceforge.net/projects/toadskin/

Toadskin is a tarpit programming language influenced by BrainF**k and Forth. It is stack-based and supports definition of Forth-like words. All instructions and words are one character in length and should be familiar to anyone who has played with BrainF**k.



:V+++++;
Toi (pl, appeared 2015)
Website: https://banna.tech/things/post/toy_language/


Toi is an imperative, type-sensitive language that provides the basic functionality of a programming language. The language was designed and developed from the ground-up by Paul Longtine. Written in C, Toi was created with the intent to be an educational experience and serves as a learning tool (or toy, hence the name) for those looking to familiarize themselves with the inner-workings of a programming language.

GitHub description: Some fools attempt at an interpreted language
toki sona (pl, appeared 2021)
Creators: Dylan Madisetti
Website: https://observablehq.com/@dmadisetti/sona

`toki pona` is a constructed human language with 140 words: Introducing`toki sona` a toki pona inspired programming language with 14 tokens and a 1000 character interpreter


GitHub description: a simple language with a 1000 character interpreter inspired by toki pona
TOM object-oriented (pl, appeared 1999)


TOM was an object-oriented programming language developed in the 1990s that built on the lessons learned from Objective-C. The main purpose of TOM was to allow for "unplanned reuse" of code via a well-developed extension mechanism. This concept was introduced seemingly by accident in Objective-C and later proved to be of wide use, and was applied aggressively in TOM. The primary changes in TOM are the addition of multiple inheritance, tuples as a first-class part of the language, cleaner syntax, free of the C requirements for header files and pre-compiler commands, and the ability to use categories (the re-use mechanism) to include anything. It is this latter ability that represents "the whole idea". Unlike Objective-C's categories that allowed only new methods to be built onto existing classes, TOM allowed the addition of class and instance variables, new methods, even new superclasses. This results in the redefinition of "class" as "a class is defined by its main definition and any extensions", these extensions have become a first-class citizen of the language (similarly to Ruby). The book The Pragmatic Programmer lists TOM as an example for a new language to learn. Development of the TOM language has ceased.
TOM (pl, appeared 2001)
Website: http://tom.loria.fr


Tom is a programming language particularly well-suited for programming various transformations on tree structures and XML based documents. Tom is a language extension which adds new matching primitives to C and Java as well as support for rewrite rules systems. The rules can be controlled using a strategy language. Tom is good for: programming by pattern matching developing compilers and DSL transforming XML documents implementing rule based systems describing algebraic transformations
Topaz (pl, appeared 2021)
Creators: m-schm
Country: Unknown
Website: https://github.com/m-schm/topaz



GitHub description: Dependently typed language that compiles to JavaScript

;; This is a comment
;; `Ven n a` represents lists that are `n` long, that contain `a`s
;; A Vec is either:
type Vec (n: Uint) (a: Type) =
  ;; empty, with length 0...
  Nil: {a} -> Vec 0 a
  ;; or 1 item longer than a Vec of length n.
  `::`: {n a} -> a -> Vec n a -> Vec (n+1) a
;; `zip` should take two lists and return a list of pairs.
;; The two lists are required to be the same length because `n` is the same for
;; both parameters.
let zip {n a b} (left: Vec n a) (right: Vec n b): Vec n (a, b) =
  match left, right in
    ;; Either both lists are empty...
    Nil,     Nil     => Nil
    ;; or they both contain at least one item.
    x :: xs, y :: ys => (x, y) :: zip xs ys
    ;; No other cases are needed, because the lists are the same length!
tornado (template, appeared 2009)
Origin: Facebook
Website: http://www.tornadoweb.org/en/stable/guide/templates.html



GitHub description: Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed.

<html>
  <head>
     <title>{{ title }}</title>
  </head>
  <body>
    <ul>
      {% for item in items %}
        <li>{{ escape(item) }}</li>
      {% end %}
    </ul>
  </body>
</html>