Questions Columns Rows
GitHub icon

Search Results

Searched 4,842 files and found 942 matches in 2.20s.

title description
prompter “Blood and Laurels”, “Bramble House” and other Versu titles are instead written in a language called Prompter which compiles down to Praxis. Besides making it feasible to write large-scale narratives for Versu, Prompter has two other goals: to enable faster development, and to make Versu content more human-readable. Readability matters. It matters for all soware, in fact, but especially here. In Prompter, the basic unit for grouping code together is the “scene”.
3D Logo “3D Logo” for the Apple IIGS, which supports 3D drawing by rotating the turtle into or out of the screen
Ć Ć programming language. Translated automatically to C, C++, C#, Java, JavaScript, Python, Swift, TypeScript and OpenCL C.
xs xs is a dynamically typed, dynamically scoped, concatenative array language inspired by kdb+/q and released into the public domain. The interpreter and builtin functions are written in OCaml. The name “xs” either stands for: eXtra Small or The plural of “x”.
Workfl workfl is a lightweight markup language for simple workflow diagrams.
lambda untyped λ-calculus, several evaluation strategies
ugBASIC ugBASIC is an isomorphic and open source language, fully documented and designed to develop portable programs, without sacrificing efficiency. With a single source it is therefore possible to create games for numerous 8 bit platforms.
ulisp uLisp® is a version of the Lisp programming language specifically designed to run on microcontrollers with a limited amount of RAM.
shakti the latest iteration of k, Shakti k. The language is capable of managing streaming, in-memory, historical, relational, and time-series data. The distributed model extends out to multiple machines whether on-premise or in the cloud. Shakti k provides connectivity via Python, HTTP, SSL/TLS, and json. Shakti k supports compression and encryption for data, whether in-memory, in-flight or on disk. Shakti k also has primitives for blockchain operations.
tangledown tangledown combines the simplicity of Markdown syntax with the sexiness of Tangle.js reactive documents and the loveliness of Rickshaw plots
specrtl specRTL (Spec Register Transfer Language) is a language designed to replace the existing RTL form machine descriptions which along with C Code forms the backend of GCC.
setlx setlX is an interpreter for the high level programming language SetlX (set language extended). The most distinguishing feature of this language is the support it offers for sets and lists. As set theory is the language of mathematics, many mathematical algorithms that are formulated in terms of set theory have very straightforward implementations in SetlX. Designed mostly by Karl Stroetmann, the SetlX language is an evolution of Setl by Jack Schwartz. It was specifically conceived to make the unique features of Setl more accessible to today's computer science students. This interpreter is currently the SetlX reference implementation.
orca orca is yet another script language which supports OO & distribute processing & functional programming aspects. And It's useful in string processing with decode statements & regular expression in it.
Occam π occam-pi is a concurrent programming language using the process-oriented programming model, which aims to make it straightforward to write correct, expressive concurrent programs. occam-pi is supported on a variety of platforms by a collection of open source tools, and is used and maintained by a community of developers around the world.
boa object-oriented, eager, first-class functions, dynamic types, extensible objects
o42a o42a is a high-level general purpose programming language. It is: compiled, statically-typed, prototype-based, logic-driven, and primarily declarative, while the imperative programming style is also supported. A program written in o42a is closer to natural English text than one written in any C-like programming language. The language is designed with programming productivity and code maintainability as main priorities. This achieved by powerful, yet restrained, semantics, and expressive and natural syntax.
morfa new programming language – general purpose and DSL-friendly
mimium mimium (MInimal Musical medIUM) a programming language as an infrastructure for sound and music.
miniprolog logic programming, Horn clauses, unification
miniML_error like miniml that can also abort execution
Linker Script ld combines a number of object and archive files, relocates their data and ties up symbol references. Usually the last step in compiling a program is to run ld. ld accepts Linker Command Language files written in a superset of AT&T’s Link Editor Command Language syntax, to provide explicit and total control over the linking process.
poly lazy, functional, statically typed, parametric polymorphism, type inference
minihaskell lazy, functional, integers, booleans, lists, recursion, statically typed
SoQL language for querying and creating data in social networks. The language is designed to meet the growing need of social networks participants to efficiently manage the large, and quickly growing, amounts of data available to them, as well as automate processes of creating new data.
JSON lambda jl ("JSON lambda") is a tiny functional language for querying and manipulating JSON.
Red interested in pure functional programming, with no side-effects on storage or the external world.
calc_var integer arithmetic +, -, *, /, variables
calc integer arithmetic +, -, *, /
Iterm2 iTerm2 is a replacement for Terminal and the successor to iTerm. It works on Macs with macOS 10.14 or newer. iTerm2 brings the terminal into the modern age with features you never knew you always wanted.
htmx htmx gives you access to AJAX, CSS Transitions, WebSockets and Server Sent Events directly in HTML, using attributes, so you can build modern user interfaces with the simplicity and power of hypertext
Shared Dataspace Language he authors are currently evaluating the use of shared dataspace paradigm as the basis for a novel programming language, called SDL (Shared Dataspace Language), that supports large-scale concurrency. Their goal is to develop the software support needed for the design, analysis, understanding, and testing of programs involving many thousands of concurrent processes running on a highly parallel multiprocessor. The authors provide an overview of the key SDL features, using small examples to illustrate its power and flexibility
FML fml is an optimizing, function-oriented, array programming language. Unlike other array programming languages, it aims to have a less symbol-heavy but still concise syntax, and non-strict semantics that allow for high-level optimization. Note that fml is not: meant for serious use always faster than systems languages like C/C++/etc. always more expressive than general-purpose languages like Python, Javascript, etc. suitable for cryptography, real-time, or low-level applications that require fine control of time and space complexity
flowchart.fun flowchart.fun is a lightweight application to generate flowcharts and diagrams from text.
fizz fizz is an experimental language and runtime environment for the exploration of cognitive architectures and combined Machine Learning (ML) and Machine Reasoning (MR) solutions. It is based primarily on symbolic programming and fuzzy formal logic and it features a distributed (as in heterogeneous computer cluster), concurrent, asynchronous and responsive inference engine.
erg erg: A Python-compatible statically typed language written in Rust
sub eager, mutable records, statically typed, subtyping
miniml eager, functional, recursive functions, statically typed, compiler, abstract machine
ERB eRuby (Embedded Ruby) is a templating system that embeds Ruby into a text document.
ed script diff can produce commands that direct the ed text editor to change the first file into the second file. These are often called "ed scripts".
crmsh crmsh is a cluster management shell for the Pacemaker High Availability stack.
cperl cperl is a better variant of Perl 5 with many Perl 6 based features and improvements, but without breaking compatibility. CPAN works. It is a "perl 11", 5 + 6 = 11.
levy call-by-push value, statically typed
modl c-based language for ExtendSim.
Blacklight blacklight is a general-pupose multithreading concatenative stack-based programming language with first-class queues and objects with delegation.
axt-format axt alignment files are produced from Blastz, an alignment tool available from Webb Miller's lab at Penn State University. The axtNet and axtChain alignments are produced by processing the alignment files with additional utilities written by Jim Kent at UCSC.
attoparsec attoparsec is a fast Haskell parser combinator library, aimed particularly at dealing efficiently with network protocols and complicated text/binary file formats.
angr angr is an open-source binary analysis platform for Python. It combines both static and dynamic symbolic ("concolic") analysis, providing tools to solve a variety of tasks.
p4p an alternate syntax for Racket.
Aime aime is an imperative procedural programming language, with a C inspired syntax.
aQasm aQasm can be executed as of today on a quantum simulator but also on quantum accelerators or physical quantum computers as soon as they are developed.
wah a slightly higher-level language superset of webassembly
mlite a lightweight (and slightly odd) inhabitant of the ML universe.
Halide a language for fast, portable computation on images and tensors
Common Authentication Protocol Specification Language a high-level language to support security analysis of cryptographic authentication and key distribution protocols. It is translated to CIL, an intermediate language expressing state transitions with term-rewriting rules. Connectors are being written to adapt CIL to supply input to different security analysis tools, including PVS for inductive verification and Maude for model-checking.
hac a hardware description language. The HAC language is based on the CAST (Caltech Asynchronous Synthesis Tool) language.
Yacas a general-purpose computer algebra system. The name is an acronym for Yet Another Computer Algebra System.
hasklig a code font with monospaced ligatures
toki 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
Hyperscript _hyperscript is a small, open scripting language inspired by hypertalk
Zimpl Zimpl is a little language to translate the mathematical model of a problem into a linear or nonlinear (mixed-) integer mathematical program expressed in .lp or .mps file format which can be read and (hopefully) solved by a LP or MIP solver.
Zeek Zeek's domain-specific scripting language enables site-specific monitoring policies.
z2 Z2 is a statically-typed pure-OOP general-use performance-centric systems-programming language.
Z-flat Z-flat is a compiled, statically-typed programming language. Its design goals are intuitive syntax, type-safety, and easy library management.
Z notation Z is not an executable notation. In general, Z specifications cannot be interpreted or compiled into a running program (or prototype or simulation). Z is not a programming language. Z texts are not just programs written in very high-level language. What would be the point of writing the program twice? Z was designed for people, not machines. For years Z was exclusively a pencil-and-paper notation.
yoga Yoga is purely functional, meaning that every function takes inputs and returns outputs, without any side effects. Yoga programs have an implicit main loop, which is run every time a hardware sensor reports new values. It then propagates updates through the program like a spreadsheet. Yoga’s lexical syntax is close enough to JavaScript that you can use JavaScript syntax highlighting in your editor.
YESS YESS: A Reboot Of RSS. The protocol is a subset of HTML and CSS. It's central design idea is to split static HTML files up into small single-screen components, called Scenes.
YARA YARA is a tool aimed at (but not limited to) helping malware researchers to identify and classify malware samples. With YARA you can create descriptions of malware families (or whatever you want to describe) based on textual or binary patterns. Each description, a.k.a rule, consists of a set of strings and a boolean expression which determine its logic.
XQL XQL: A Query Language for XML Data
XQL XQL is a query language designed specifically for XML. In the same sense that SQL is a query language for relational tables and OQL is a query language for objects stored in an object database, XQL is a query language for XML documents.
xduce XDuce is a statically typed programming language for XML processing. Its basic data values are XML documents, and its types (so-called regular expression types) directly correspond to document schemas. XDuce also provides a flexible form of regular expression pattern matching, integrating conditional branching, tag checking, and subtree extraction, as well as dynamic typechecking. We survey the principles of XDuce’s design, develop examples illustrating its key features, describe its foundations in the theory of regular tree automata, and present a complete formal definition of its core, along with a proof of type safety.
X BitMap XBM files differ markedly from most image files in that they take the form of C source files.
xsharp X# is an open source development language for .NET, based on the xBase language.
visdown Write visualisation using a simple declarative markup like you would write code. Just wrap it in fenced block (three backticks) and mark the language as `vis`.
Wren Wren is a small, fast, class-based concurrent scripting language.
Worst Worst is a simple, malleable programming language built for extensibility and creativity. Its syntax system allows you to redefine the entire language as you wish.
Wonkey Wonkey is an open-source cross-platform programming language.
MPS With MPS you can define custom editors for a new language and make using these DSLs simpler. Even domain experts, who are not familiar with traditional programming, can easily work in MPS with domain-specific languages designed around their domain-specific terminology.
Wikitax Wikitax: a plaintext markup syntax to indicate semantical, display, and formatting information for text in CMSes, wikies, and blogs.
whalecalf Whale Calf is a research-level parser generator for Boolean grammars, which are context-free grammars augmented with Boolean operations. It is written by Alexander Okhotin in C++, and is mainly aimed at demonstrating different parsing algorithms, of which the most practically useful is the Generalized LR (GLR). The main development took place in 2000-2004, though (as of April 2017) some occasional corrections are still being made.
mdl We’ve created a DSL and compiler for modeling micro-architecture that handles a very broad class of architectures - CPU, GPUs, VLIWs, DSPs, ML accelerators, and embedded devices. This effort grew out of a need to quickly develop and experiment with high-quality compilers and tools to facilitate rapid architecture exploration. We named the DSL “MDL” for “Microarchitecture Description Language”
webql WebQL was developed by QL2 Softaware in 2006. It is used for data integration and collection of unstructured and structured sources including the Web, PDF and Word documents, spreadsheets, email repositories, corporate data stores and more. It is also capable of Optical Character Recognition that enables it to retrive text within images. WebQL also support XML data of arbitrary size, and APIs for embedding WebQL in C, Java or .NET programs.
WebAssembly Text Format WebAssembly has an S-expression-based textual representation, an intermediate form designed to be exposed in text editors, browser developer tools, etc.
XML Query Language We propose a query language for XML, called XML-QL, as one possible answer to these questions. The language has a SELECT-WHERE construct, like SQL, and borrows features of query languages recently developed by the database research community for semistructured data.
turnstile-plus We present Turnstile+, a metalanguage for implementing typed—particularly dependently typed—languages.
Static Typescript We present Static TypeScript (STS), a subset of TypeScript (itself, a gradually typed superset of JavaScript), and its compiler/linker toolchain, which is implemented fully in TypeScript and runs in the web browser.
flowlog We present Flowlog, a tierless language for programming SDN controllers. In contrast to languages with different abstractions for each program tier---the control-plane, data-plane, and controller state---Flowlog provides a unified abstraction for all three tiers. Flowlog is reminiscent of both SQL and rule-based languages such as Cisco IOS and JunOS; unlike these network configuration languages, Flowlog supports programming with mutable state. We intentionally limit Flowlog’s expressivity to enable built-in verification and proactive compilation despite the integration of controller state. To compensate for its limited expressive power, Flowlog enables the reuse of external libraries through callouts. Flowlog proactively compiles essentially all forwarding behavior to switch tables. For rules that maintain controller state or generate fresh packets, the compiler instructs switches to send the minimum amount of necessary traffic to the controller. Given that Flowlog programs can be stateful, this process is non-trivial. We have successfully used Flowlog to implement real network applications. We also compile Flowlog programs to Alloy, a popular verification tool. With this we have verified several properties, including program-correctness properties that are topology-independent, and have found bugs in our own programs.
cuscus We present Cuscus, a tool for data visualisation that is informed by ethnographic fieldwork across different professional sectors. Cuscus allows end-users to create novel visualisations by defining visual properties in a spreadsheet. We also report on user studies in the contexts of data journalism and business analytics, and discuss further extensions to this new interaction paradigm.
jplace We have developed a unified format for phylogenetic placements, that is, mappings of environmental sequence data (e.g., short reads) into a phylogenetic tree. We are motivated to do so by the growing number of tools for computing and post-processing phylogenetic placements, and the lack of an established standard for storing them. The format is lightweight, versatile, extensible, and is based on the JSON format, which can be parsed by most modern programming languages.
Molecular Query Language We have developed a Java library for substructure matching that features easy-to-read syntax and extensibility. This molecular query language (MQL) is grounded on a context-free grammar, which allows for straightforward modification and extension. The formal description of MQL is provided in this paper. Molecule primitives are atoms, bonds, properties, branching, and rings. User-defined features can be added via a Java interface. In MQL, molecules are represented as graphs. Substructure matching was implemented using the Ullmann algorithm because of favorable run-time performance. The Ullmann algorithm carries out a fast subgraph isomorphism search by combining backtracking with effective forward checking. MQL software design was driven by the aim to facilitate the use of various cheminformatics toolkits. Two Java interfaces provide a bridge from our MQL package to an external toolkit: the first one provides the matching rules for every feature of a particular toolkit; the second one converts the found match from the internal format of MQL to the format of the external toolkit. We already implemented these interfaces for the Chemistry Development Toolkit.
xt3d We have designed and implemented xt3d, a highly declarative xml specification language. It demands little more from users than a knowledge of the expected input and desired output. We illustrate the power of xt3d with several examples, including one reminiscent of polytypic programming that greatly simplifies the import of xml values into general-purpose languages. . xt3d is itself an xml language, so users do not need to learn a new surface syntax. The principal advantage of xt3d over xslt is that it provides an extremely simple, declarative language for describing transformations over xml elements.
Patchwork We have built a system, Patchwork, that allows programs to be organized according to a dataflow model. In our implementation, application programs use Patchwork to assemble complex microcode programs for a graphics processor from a library of microcode modules. We describe a simple and efficient implementation, in which the only overhead incurred is a single extra level of indirection when invoking a module or when a module accesses inputs, outputs, or local storage. The implementation depends on being able to describe a distinct execution tree for the network, which obviates the need both for run-time monitoring of the execution and for movement of data. Thus, neither dataflow hardware nor a dataflow language is needed for the implementation. Patchwork supports flow-of-control constructs such as looping and branching, the assembly of complex modules from simpler ones, modules written in a variety of languages for a variety of different devices, the interleaved execution of several programs on a single processor, and the execution of a single program on a set of processors in parallel. An analysis showed that Patchwork contributed between 2 and 5% to the total running time of sample microcode programs.
rbs We defined a new language called RBS for type signatures for Ruby 3. The signatures are written in .rbs files which is different from Ruby code. You can consider the .rbs files are similar to .d.ts files in TypeScript or .h files in C/C++/ObjC. The benefit of having different files is it doesn't require changing Ruby code to start type checking. You can opt-in type checking safely without changing any part of your workflow.
Water Water is a new native Web service programming language with a ConciseXML syntax. Data, logic, and presentation have a uniform XML representation in Water. Read how Water simplifies the creation of new Web services and programs.
walt Walt is a JavaScript-like syntax for WebAssembly text format
wizml WIZML is a sublanguage of VTML. It is a tag-based programming language which is used to define the logic of writing out the code to one or more documents based on user input in a Tag Editor or a Wizard.
Wolfram Data Framework WDF is a human-readable plaintext format that can be rendered in JSON, XML and other forms.
Volt Volt is a C-inspired programming language that toes the line between expressiveness and control.
Vim script Vim script (also called vimscript or VimL) is the scripting language built into Vim.
Vim Scripts Vim Scripts allows users to upload scripts that help enhance vim.
video Video is a language for making movies. It combines the power of a traditional video editor with the capabilities of a full programming language. Video integrates with the Racket ecosystem and extensions for DrRacket to transform it into a non-linear video editor.
verifpal Verifpal is new software for verifying the security of cryptographic protocols. The Verifpal language is meant to illustrate protocols close to how one may describe them in an informal conversation, while still being precise and expressive enough for formal modeling. Verifpal reasons about the protocol model with explicit principals: Alice and Bob exist and have independent states.
Vely Vely is an embedded programming language with C as a host language. It's precompiled into C, creating a native executable.
Velocity Template Language Velocity is a Java-based template engine. It permits web page designers to reference methods defined in Java code.
Vcpkg Vcpkg helps you manage C and C++ libraries on Windows, Linux and MacOS. This tool and ecosystem are constantly evolving; your involvement is vital to its success!
filetab-d Variant of Filetab for x86 and PDP-11. A decision based language which was unusual in that it consisted predominantly of matrices. Users included developers writing insurance software at a company in Manchester.
plink-map-format Variant information file accompanying a .ped text pedigree + genotype table.
Vale Vale is a tool for constructing formally verified high-performance assembly language code, with an emphasis on cryptographic code. It uses existing verification frameworks, such as Dafny and F*, for formal verification. It supports multiple architectures, such as x86, x64, and ARM, and multiple platforms, such as Windows, Mac, and Linux. Additional architectures and platforms can be supported with no changes to the Vale tool.
Visual Tool Markup Language VTML is a family of markup languages used to extend the IDE of HomeSite and ColdFusion Studio. Using VTML you can define your own Tag Insight and Tag Editors, which is very helpful when developing your own custom tags, since you can simply put the VTML files inside your distribution, enabling your custom tags to tightly integrate into the ColdFusion Studio IDE. As the name (Markup Language) might suggest, VTML is a tag-based language (CFML is also tag-based) and therefore easy to learn.
versioned-text-markup-language VTML (Versioned Text Markup Language), a markup language for storing document version information. VTML can easily be implemented within a text editor, and provides a notation and semantics for tracking successive revisions to a document. The main purpose of VTML is to allow asynchronous collaboration in the creation and editing of text documents.
Very Tiny Language VTL-2 is the second Very Tiny Language developed for the Altair 680 Computer system. VTL-2 represents an enormous improvement over the earlier VTL-1 language, and incorporates some thirty additional features. In spite of these enhancements, it still requires only 768 bytes of Read-Only-Memory, and still fits into the three empty PROM sockets already on the 680 CPU board.
Hodor Using jumbled permutations of the word "hodor" over and over again we have simplified programming syntax to make it easier than ever before.
Uniform eXchange Format Uniform eXchange Format (uxf) is a plain text human readable optionally typed storage format that supports custom types. It may serve as a convenient alternative to csv, ini, json, sqlite, toml, xml, or yaml
UnQL UnQL is a database query language, akin to SQL, but designed for modern document-oriented databases. SQL assumes a rigidly defined data schema. Each table has a fixed number of columns and each column has a defined datatype. UnQL assumes a more flexible approach to storing data. Instead of "tables", UnQL uses "collections". (The concept is the same, but the name is changed since "tables" are square whereas "collections" can be of varying shape.) Each collection consists of zero or more documents represented as JSON strings. A document in UnQL corresponds to a row in SQL
Umka Umka is a statically typed embeddable scripting language.
UCG UCG is a universal grammar for configuration. UCG's goal is not to define a configuration format like JSON, YAML, or TOML. It is not intended to replace the other serialization formats. Instead it is intended to provide a common grammar for generating those formats.
U U is a small functional programming language, designed mainly for explorational and educational uses. Both its syntax and its operational rules are very simple and regular. U can be considered a functional-style calculator for several useful types of data, preloaded with a large number of built-in operators and extensible through defining new ones.
Typoscript TypoScript is a syntax for defining information in a hierarchical structure using simple ASCII text content.
typedefs Typedefs is a programming language agnostic, algebraic data type definition language, written in Idris.
TypeScript Type Declarations TypeScript .d.ts files are declaration files that contain only type information. These files don't produce .js outputs; they are only used for typechecking.
txtzyme Txtzyme was created around 2010-2012 by Ward Cunningham. Txtzyme has the advantage that it is specifically oriented to I/O control and interaction - yet surprisingly simple.
twoducks TwoDucks is an esoteric programming language by User:Zzo38 which allows you to go back in time and change things. It is uncomputable on a Turing machine; it even allows you to solve the halting problem.
turnstile Turnstile aims to help Racket programmers create typed languages. It does so with extensions of Racket’s macro-definition forms that facilitate implementation of type rules alongside normal macro code. As a result, the macros implementing a new language directly type check the program during expansion, obviating the need to create and call out to a separate type checker. Thus, a complete typed language implementation remains a series of macro definitions that may be imported and exported in the standard way that Racket programmers are accustomed to.
Jekyll Transforms your plain text into static websites and blogs.
Xoc Today’s system programmers go to great lengths to extend the languages in which they program. For instance, system-specific compilers find errors in Linux and other systems, and add support for specialized control flow to Qt and event-based programs. These compilers are difficult to build and cannot always understand each other’s language changes. However, they can greatly improve code understandability and correctness, advantages that should be accessible to all programmers. We describe an extension-oriented compiler for C called xoc. An extension-oriented compiler, unlike a conventional extensible compiler, implements new features via many small extensions that are loaded together as needed. Xoc gives extension writers full control over program syntax and semantics while hiding many compiler internals. Xoc programmers concisely define powerful compiler extensions that, by construction, can be combined; even some parts of the base compiler, such as GNU C compatibility, are structured as extensions.
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.
InfluxDB Time-series database management system
Tiki Wiki Markup Tiki Wiki's Wiki Syntax.
magritte This work proposes Magritte, a general-purpose language that is viable as a shell scripting language
Pλ⍵NK This work presents Pλ⍵NK, a functional probabilistic network programming language that extends Probabilistic NetKAT (PNK). Like PNK, it enables probabilistic modelling of network behaviour, by providing probabilistic choice and infinite iteration (to simulate looping network packets). Yet, unlike PNK, it also offers abstraction and higher-order functions to make programming much more convenient.
tablatal This space-sensitive database format is designed to store a list of elements of the same length, accessible by id. The parser is 30 lines long, and allows for human-readable data structures for static sites such as Oscean, also see Indental. In the Tablatal file, the first line declares the key, the spacing between each key defines the length of the parameters for all subsequent lines.
Indental This space-sensitive database format is designed to store a dictionary of elements, accessible by name. The parser is a mere 50 lines, and allows for human-readable data structures for static sites such as Oscean, also see Tablatal. In the Indental file, an unindented line declares the key to a new root node, children lines can associate either parameters or lists to their parent node, a line divided with a colon will associate a value to a parameter to the parent node, and a sequence of equally indented lines will append to a list.
Kefir This repository contains implementation of C17 language compiler from scratch. No existing open source compiler infrastructure is being reused. The main priority is self-sufficiency of the project, compatibility with platform ABI and compliance with C17 language standard.
lamdu-editor This project aims to create a next-generation, live programming environment that radically improves the programming experience.
sqlar-format This program (named "sqlar") operates much like "zip", except that the compressed archive it builds is stored in an SQLite database instead of a ZIP archive.
SHADOW This paper provides an account of the Shadow language that is used to describe syntax and of a corresponding subroutine that enables a computer to perform syntactic analysis. The input to this subroutine consists of a string to be analyzed and a description of the syntax that is to be used. The syntax is expressed in the Shadow language. The output consists of a trace table that expresses the results of the syntactic analysis in a tabular form. Several versions of the subroutine and some associated programs have been in use now for over three years. The present account of the language and the subroutine contains a summary of material that has been described previously in unpublished reports and also some additional discussion of the work in relation to the more general questions of problem-oriented languages and string transformations.
bioscript This paper introduces BioScript, a domain-specific language (DSL) for programmable biochemistry which executes on emerging microfluidic platforms. The goal of this research is to provide a simple, intuitive, and type-safe DSL that is accessible to life science practitioners. The novel feature of the language is its syntax, which aims to optimize human readability; the technical contributions of the paper include the BioScript type system and relevant portions of its compiler. The type system ensures that certain types of errors, specific to biochemistry, do not occur, including the interaction of chemicals that may be unsafe. The compiler includes novel optimizations that place biochemical operations to execute concurrently on a spatial 2D array platform on the granularity of a control flow graph, as opposed to individual basic blocks. Results are obtained using both a cycle-accurate microfluidic simulator and a software interface to a real-world platform.
metalex This paper gives an overview of two XML standard proposals dealing with two complementary aspects of electronic legislation – the documents themselves as a carrier, and an institutional reality they represent – in a coherent way: MetaLex XML and the Legal Knowledge Interchange format (LKIF).
Carpet This paper describes CARPET, a high-level programming language based on the cellular automata model. CARPET is a programming language designed to support the development of parallel high performance software. It exploits the computing power of a highly parallel computer releasing a user from using explicit parallel constructs. A CARPET implementation has been used for programming cellular algorithms in the CAMEL parallel environment. By CARPET a user might write programs to describe the actions of thousands of simple active agents interacting locally, then the CAMEL environment allows a user to observe the global complex evolution that arises from their parallel execution and their local interactions.
Meta-Assembler This manual describes the SPERRY UNIVAC 1100 Series Meta-Assembler (MASM) processor and language. This manual is directed to users with basic Assembler programming knowledge and experienc€~. Definition of the machine language which is to be assembled by MASM is not given in this document. This information is available in the relevant hardware manuals. MASM is called a meta-assembler because it is not specifically bound to generating code for a particular hardwar~ architecture. With an unaltered environment, MASM will generate code for an 1100 Serit:!s hardware architecture. However, with the directives and built-in functions provided, the user may alter the environment to generate code for any hardware architecture. This assumes the output of MASM (1100 Series Relocatable Binary Format) can be converted to an acceptable form for to the operating system on .the alternate architecture. The processor accepts both Fieldata and ASCII input and maintains character constants in either code as specified by the user. MASM uses,an internal code to store character constants which do not have to be maintained iri a specific character code. MASM performs specified tasks based on the interpretation of statements received primarily via the Source Input Routine (SIR$) and produces an output. The output produced depends upon the user's request. If a relocatable binary element is requested, it is produced by the Relocatable Output Routine (ROH). M,A,SM optionally produces a printed listing of the the input and its processed form. The structure of both the input and output forms are presented elsewhere in this manual. MASM performs its function in two scans of the input. The first scan is known as the summary pass, and the second is known as the generative pass. These two passes of the source input, that is, from the first source image encountered to the last source image, are known as the main assembly. Assemblies invoked within the main assembly are known as subassemblies. Certain initialization is done at the start of each pass
onex This is the vision of the "Object Network" and its app and programming system called "Onex". Onex is a mobile app that will enable you to build your own programs and manage your own data, directly on your phone or tablet. It's as easy as spreadsheets, but can scale up over the network.
ALPAK This is the first of two papers on the ALPAK system for nonnumerical algebra on a digital computer. This paper is concerned with polynomials in several variables and truncated power series with polynomial coefficients. The second paper will discuss rational functions of several variables, truncated, power series with rational-function coefficients, and syste7ns of linear equations with rational-function coefficients. The ALPAK system has been programmed within the BE-S YS-4 monitor system on the IBM 7090 computer, but the language and concepts are machine independent.
Triton This is the development repository of Triton, a language and compiler for writing highly efficient custom Deep-Learning primitives. The aim of Triton is to provide an open-source environment to write fast code at higher productivity than CUDA, but also with higher flexibility than other existing DSLs.
stoneknifeforth This is StoneKnifeForth, a very simple language inspired by Forth. It is not expected to be useful; instead, its purpose is to show how simple a compiler can be. The compiler is a bit under two pages of code when the comments are removed. This package includes a “metacircular compiler” which is written in StoneKnifeForth and compiles StoneKnifeForth to an x86 Linux ELF executable.
The Algebra This document introduces the XML Query Algebra (``the Algebra'') as a formal basis for an XML query language.
kvsapi This document describes the Key Value Storage (KVS) Application Program Interface (API) specification for SSD storage devices with Object Drive based Key Value Storage. It provides a set of APIs that are portable across multiple vendor SSD products.
neralie-format This decimal clock has two groups of 3 digits, called the beat & the pulse. A beat contains 1000 pulses, and equivalent to 86.4 seconds.
Sweet Expressions This SRFI describes a set of syntax extensions for Scheme, called sweet-expressions (t-expressions), that has the same descriptive power as s-expressions but is designed to be easier for humans to read.
I-expressions This SRFI descibes a new syntax for Scheme, called I-expressions, whith equal descriptive power as S-expressions. The syntax uses indentation to group expressions, and has no special cases for semantic constructs of the language. It can be used both for program and data input.
omega The Ωmega interpreter is styled after the Hugs Haskell Interpreter. The Ωmega syntax is based upon the syntax of Haskell. If you’re unsure of what syntax to use, a best first approximation is to use Haskell syntax. It works most of the time. While clearly descended from Haskell, Ωmega has several important syntactic and semantic differences.
Incipit The ‘Incipit Markup Language’ (or ‘Incipit’, for short) is a plain text markup language that uses Unicode characters and the structure of the text itself to format documents.
imp-lang The vision is of an emacs-y live self-modifying environment for working with structured data across multiple devices. The big moving parts are: a versioned relational database; an extensible GUI; a pure programming language built around relations; an interpreter with fast incremental view maintenance.
tibet The very, very first Javascript framework ever designed. “...in awe of what you’ve done with JS.” — Brendan Eich, JavaScript’s creator.
tremor-query The tremor query language, tremor-query or trickle is an interpreted statement-oriented language designed for continuous online structured queries with support filtering, extraction, transformation and streaming of structured data in a stream or event-based processing system.
tidyverse The tidyverse is an opinionated collection of R packages designed for data science. All packages share an underlying design philosophy, grammar, and data structures.
MediaWiki The syntax and keywords used by the MediaWiki software to format a page.
arezzo-notation The stave of 4 lines is usually attributed to an Italian Benedictine Monk called Guido of Arezzo (approx. 991-1033). In "Micrologus" a treatise on music notation, he also used the initial letters of a hymn to define musical pitches. These letters were ut, re mi, fa, sol, la. In most countries "Ut" became "Do" and centuries later with the addition of "ti" the system came to be called the sol-fa notation which was taught in many schools.
Grace The purpose of Grace is to allow novices to discover programming in the simplest possible way. Other famous languages such as Java or Python are widely used by professionals, but may be hard to assimilate for a beginner in programming. That is what the object-oriented Grace language is made for.
GCC GENERIC The purpose of GENERIC is simply to provide a language-independent way of representing an entire function in trees. To this end, it was necessary to add a few new tree codes to the backend, but most everything was already there. If you can say it with the codes in gcc/tree.def, it’s GENERIC.
BETA Project The promising 'BETA project'' in Novosibirsk primarily designed by Dr. A. P. Ershov, M. Shvartsman, A. A. Baehrs was intended to produce compilers from language descriptions almost automatically, and it had Algol 68, PL/I and Simula 67 as its first objectives
Meta Expressions The project of defining M-expressions precisely and compiling them or at least translating them into S-expressions was neither finalized nor explicitly abandoned. It just receded into the indefinite future, and a new generation of programmers appeared who preferred internal notation to any FORTRAN-like or ALGOL-like notation that could be devised.
ZIM Format The openZIM project proposes offline storage solutions for content coming from the Web.
net-format The net file format is used to describe the axtNet data that underlie the net alignment annotations in the Genome Browser. In 2016 it was revised so that line indentation level represents the parent/child relationship between records and is a necessary part of the net file format. Child records are indented one space from the parent, as shown in the example net file below.
Spin The multicore Propeller microcontroller opens up a new level of invention possibilities for students. Programming it in its native high-level language, Spin, makes optimal use of this unique and powerful multicore microcontroller. Spin's design was inspired by great attributes of three other languages, Delphi, C, and Python, and by envisioning new solutions to common programming problems. Like Python, Spin uses indentation whitespace, rather than curly braces or keywords, to delimit blocks.
Xgboost The model and data format of XGBoost is exchangeable, which means the model trained by one language can be loaded in another. This means you can train the model using R, while running prediction using Java or C++, which are more common in production systems. You can also train the model using distributed versions, and load them in from Python to do some interactive analysis.
Linked Markdown The main intended use is writing legal agreements and law. A Linked Markdown file has a first sections containing definitions, and a second section containing Markdown. They are separated by three lines.
starlark The language used in Bazel. Starlark is designed to be small, simple, and thread-safe. Although it is inspired from Python, it is not a general-purpose language and most Python features are not included. Starlark is syntactically a subset of Python 3
Praat Script The language is bundled with Praat, a speech analysis tool, to execute menu and action commands.
Game Maker Language The language historically tries to accommodate different programming backgrounds and styles - BASIC/Lua style "and" / "or" keywords can be used interchangeably with C-style "&&" / "||" operators; parentheses around conditions in if-statements and loops can be omitted; semicolons are largely optional[26] (insertion happens at the end of statement; compile error is raised in case of ambiguity). The language's default mode of operation on native platforms is via a stack machine; it can also be source-to-source compiled to C++ via LLVM for higher performance.[27] On HTML5, GML is source-to-source compiled to JavaScript with optimizations and minification applied in non-debug builds.
VEX The lambda calculus is a formal symbolic term rewrite system that has been used for many years both as a mechanism for defining the semantics of programming languages, and as the basis for functional programming languages. In this paper, we describe a completely visual representation for lambda expressions, VEX, that has several advantages over traditional textual lambda calculus. Although VEX is designed as an expression-oriented component of VIPR [3, 4], it can also be used in teaching the concepts of lambda calculus as a replacement for or augmentation to the teaching of traditional textual rewrite rules. Many semantic issues in lambda calculus that are confusing to students, including substitution, free variables, and binding, become apparent and explicit in VEX.
ROS Message The format of this language is simple: a message description is a list of data field descriptions and constant definitions on separate lines.
Flow9 The flow programming language, a safe, functional strongly-typed programming language
LISP 1.5 The first version of LispLanguage to become popular.
KaTeX The fastest math typesetting library for the web.
maraca-lang The dynamic structured data language. Maraca is a lightweight, embeddable, declarative language for defining & manipulating dynamic structured data. And when combined with Maraca-Render, it can be a powerful language for creating interactive UI, such as this site...
dfns The dfns language is a functionally oriented, lexically scoped dialect of APL.
Stutter The design goals of the Stutter Programming Language focus on the underlying idea that Stutter Code is a speakable language that contains no special syntax characters that are unpronounciable.
sqlite-storage-format The complete state of an SQLite database is usually contained in a single file on disk called the "main database file". During a transaction, SQLite stores additional information in a second file called the "rollback journal", or if SQLite is in WAL mode, a write-ahead log file.
chain-format The chain format describes a pairwise alignment that allow gaps in both sequences simultaneously. Each set of chain alignments starts with a header line, contains one or more alignment data lines, and terminates with a blank line. The format is deliberately quite dense.
bigWig format The bigWig format is the recommended format for almost all graphing track needs. The bigWig format is useful for dense, continuous data that will be displayed in the Genome Browser as a graph. BigWig files are created from wiggle (wig) type files using the program wigToBigWig. bigWig files are indexed binary files.
ycp The YaST-language YCP is a scripting language to be interpreted by the YCP-engine (YCP interpreter) specially designed for manipulation with a system configuration. Its syntax is very similar to C programming language. Because YCP can make use of the whole infrastructure that YaST provides, the actions that can be accomplished with YCP are very powerful.
WDL The Workflow Description Language (WDL) is a way to specify data processing workflows with a human-readable and -writeable syntax. WDL makes it straightforward to define analysis tasks, chain them together in workflows, and parallelize their execution. The language makes common patterns simple to express, while also admitting uncommon or complicated behavior; and strives to achieve portability not only across execution platforms, but also different types of users. Whether one is an analyst, a programmer, an operator of a production system, or any other sort of user, WDL should be accessible and understandable.
Uno The Uno langauge is a dialect of C#, designed for cross-compilation to C++ and other languages. Uno does not require the .NET Framework, but has instead a more lightweight library called UnoCore. The syntax of Uno is more or less identical to C#, with deviations documented here.
Troff The Text Processor for Typesetters
Table Query Language The Table Query Language (TaQL) is an SQL-like high level language to do operations like selection, sort, and update on a casacore table. It is a very versatile language with full support for table columns containing array data. It has inherent support for masked arrays, units, and astronomical coordinates. It has a very rich set of functions (like cone search and array reduction) making it very suitable for astronomical applications. User defined functions can be added easily. It also has full support of grouping/aggregation and nested queries. An operation that can be expressed in a single function is the matching of two sky catalogues. It can be used from C++, Python, and the Casacore program taql.
synergist The Synergist language was created by a crew out of Michigan (USA) somewhere around 1986 or 1987. A guy named Kingsbury (can't remember his first name, but he's the brother of Digital Equipment Corporation guru Dan Kingsbury at https://networkingdynamics.com), was one of the principals in the group. Work on the project stopped by 1990.
shiv The Shiv programming language is a language designed around extending the langauge itself. Its main features include: Simple, light-weight yet expressive syntax; Powerful metaprogramming capabilities.
RPL The Relational Production Language (RPL) solves the paradigm mismatch between expert systems and database systems by relying on the relational data model as the underlying formalism for an expert system. The result is a formally-defined production system language with immediate access to conventional databases. Working memory is modeled as a relational database and rules consist of a relational query on the left hand side (LHS) and database updates on the right hand side (RHS).
Readable The ReAdABLE Human Format aims at Agile Documentation by making WRITING and READING document easier for End User and Developer alike, while allowing a high degree of flexibility. Its primary goal is to generate Markdown (and conversion to other formats in the future) while being even simpler (less code to memorize) and richer (adding meta-data is straightforward and creating new semantics is easy).
python-cl-compiler The Python compiler for CMU Common Lisp has been under development for over five years, and now forms the core of a production quality public domain Lisp implementation. Python synthesizes the good ideas from Lisp compilers and source transformation systems with mainstream optimization and retargetability techniques. Novel features include strict type checking and source-level debugging of compiled code. Unusual attention has been paid to the compiler's user interface.
torchscript The PyTorch 1.0 release candidate introduces Torch Script, a Python subset that can be JIT-compiled into C++ or other high-speed code.
Prisma Schema Language The Prisma schema file (short: schema file, Prisma schema or schema) is the main configuration file for your Prisma setup. It is typically called schema.prisma and consists of the following parts:
PowerQuery M The Power Query M formula language is optimized for building highly flexible data mashup queries. It's a functional, case sensitive language similar to F#.
Post-X The Post-X language is designed to provide facilities for pattern-directed processing of strings, sequences and trees in an integrated applicative format.
ppm-format The PPM format is a lowest common denominator color image file format. It should be noted that this format is egregiously inefficient. It is highly redundant, while containing a lot of information that the human eye can't even discern. Furthermore, the format allows very little information about the image besides basic color, which means you may have to couple a file in this format with other independent information to get any decent use out of it. However, it is very easy to write and analyze programs to process this format, and that is the point.
phylip The PHYLIP file format stores a multiple sequence alignment. The format was originally defined and used in Joe Felsenstein’s PHYLIP package [R165], and has since been supported by several other bioinformatics tools
Netpbm grayscale image format The PGM format is a lowest common denominator grayscale file format. It is designed to be extremely easy to learn and write programs for. (It's so simple that most people will simply reverse engineer it because it's easier than reading this specification).
Portable Bit Map Format The PBM format is a lowest common denominator monochrome file format. It serves as the common language of a large family of bitmap image conversion filters. Because the format pays no heed to efficiency, it is simple and general enough that one can easily develop programs to convert to and from just about any other graphics format, or to manipulate the image. The name "PBM" is an acronym derived from "Portable Bit Map."
opengraph The Open Graph protocol enables any web page to become a rich object in a social graph. For instance, this is used on Facebook to allow any web page to have the same functionality as any other object on Facebook.
OCL The Object Constraint Language (OCL) is a textual sublanguage of the Unified Modelling Language (UML). It can be used to express additional constraints on UML models that cannot be expressed, or are very difficult to express, with the graphical means provided by UML. OCL is based on first-order predicate logic but it uses a syntax similar to programming languages and closely related to the syntax of UML. It is, thus, more adequate for every-day modelling than pure first-order predicate logic.
oasis-operating-system The OASIS operating system was originally developed and distributed in 1977 by Phase One Systems of Oakland, California (President Howard Sidorsky). OASIS was developed for the Z80 processor and was the first multi-user operating system for 8-bit microprocessor based computers (Z-80 from Zilog). "OASIS" was a backronym for "Online Application System Interactive Software".
NELIAC The Navy Electronics Laboratory International ALGOL Compiler or NELIAC is a dialect and compiler implementation of the ALGOL 58 programming language developed by the Naval Electronics Laboratory in 1958.
Monaco Editor The Monaco Editor is the code editor that powers VS Code.
Homebrew The Missing Package Manager for macOS.
Marine Trading Markup Language The Marine Trading Markup Language (MTML), formalized in the MTML Document Type Definition, "is a standard to help a broad base of small, medium and large buyers and suppliers in the marine trading industry conduct their fundamental trading transactions electronically via the Internet."
manticore The Manticore project is an effort to design and implement a new functional language for parallel programming. Unlike many earlier parallel languages, Manticore is a heterogeneous language that supports parallelism at multiple levels. Specifically, the Manticore language combines Concurrent ML-style explicit concurrency with fine-grain, implicitly threaded, parallel constructs. These lectures will introduce the Manticore language and explore a variety of programs written to take advantage of heterogeneous parallelism. At the explicit-concurrency level, Manticore supports the creation distinct threads of control and the coordination of threads through first-class synchronous-message passing. Message-passing synchronization, in contrast to shared-memory synchronization, fits naturally with the functional-programming paradigm. At the implicit-parallelism level, Manticore supports a diverse collection of parallel constructs for different granularities of work. Many of these constructs are inspired by common functional-programming idioms. In addition to describing the basic mechanisms, we will present a number of useful programming techniques that are enabled by these mechanisms. Finally, we will briefly discuss some of the implementation techniques used to execute Manticore programs on commodity multicore computers.
Manchester syntax The Manchester syntax is a user-friendly compact syntax for OWL 2 ontologies; it is frame-based, as opposed to the axiom-based other syntaxes for OWL 2. The Manchester Syntax is used in the OWL 2 Primer, and this document provides the language used there. It is expected that tools will extend the Manchester Syntax for their own purposes, and tool builders may collaboratively extend the common language.
SAOL The MPEG-4 Structured Audio Orchestra Language
ACT-III The LGP-30 had a high-level language called ACT-III. Every token had to be delimited by an apostrophe, making it hard to read and even harder to prepare tapes.
JavaScriptCore The JavaScriptCore framework provides the ability to evaluate JavaScript programs from within Swift, Objective-C, and C-based apps. You can use also use JavaScriptCore to insert custom objects into the JavaScript environment.
ttsneo The Japanese programming language "TTSneo" is a scripting language that makes it easy to program in Japanese.
JSON5 The JSON5 Data Interchange Format (JSON5) is a superset of JSON that aims to alleviate some of the limitations of JSON by expanding its syntax to include some productions from ECMAScript 5.1.
VHDL-AMS The IEEE 1076.1 language, a hardware description language for the description and the simulation of analog, digital, and mixed-signal systems, is defined in this standard. The language, also informally known as VHDL-AMS, is built on IEEE Std 1076-2008 (VHDL) and extends it with additions and changes to provide capabilities of writing and simulating analog and mixed-signal models.
hecl The Hecl Programming Language is a high-level, open source mobile scripting language inspired by the minimalism and power of tcl written in Java.
Harwell-Boeing file format The Harwell-Boeing format is the most popular mechanism for text-file exchange of sparse matrix data.
Gofer The Gofer system is a functional programming environment for a small, Haskell-like language. Supporting a wide range of different machines, including home computers, the system is widely used, both for teaching and research.
GAMS The General Algebraic Modeling System (GAMS) is a high-level modeling system for mathematical programming and optimization. It consists of a language compiler and a stable of integrated high-performance solvers. GAMS is tailored for complex, large scale modeling applications, and allows you to build large maintainable models that can be adapted quickly to new situations. GAMS is specifically designed for modeling linear, nonlinear and mixed integer optimization problems.
g-expressions The GNU Guix project invented G-Expressions to make it easier to "stage" data or code, in the form of S-Expressions, for later manipulation or evaluation. They are similar to S-Expressions, hence the name, but they provide useful code staging features beyond what can be easily accomplished with just "quasiquote" and "unquote". A high-level object (such as a Guix package) can be included in a G-Expression; the transitive dependencies of that high-level object will then be automatically carried along with the G-Expression. When the G-Expression is converted to an S-Expression and stored on disk for later manipulation or evaluation, the high-level object will be automatically "lowered" to an appropriate representation (such as the package's output path) via a "compiler". Compared to direct manipulation of S-Expressions, G-Expressions can provide a simpler and more intuitive way to stage data or code.
Google Data Protcol The GData Protocol is a REST-inspired technology for reading, writing, and modifying information on the web. It supports two primary modes of access, AtomPub and JSON.
ACOS The GBBS-Pro system was based on the ACOS compiler and language. ACOS was a BASIC-like language wherein the modem handling routines had replaced some of the other basic functions. Arrays (for instance) were unheard of in ACOS and so it was necessary to find other ways to work around these limitations (i.e. files replaced arrays).
DOI The DOI system provides a technical and social infrastructure for the registration and use of persistent interoperable identifiers, called DOIs, for use on digital networks.
Conceptual The Conceptual language aims to completely separate all features and quirks of programming and bring them to the realm of concepts, bridging machines and minds. This language is not a goal in itself, but a platform for the future; understanding this future allows to put its features into their proper context.
COM Structured Storage The Compound File Binary File Format, a general-purpose file format that provides a file-system-like structure within a file for the storage of arbitrary, application-specific streams of data.
CWL The Common Workflow Language (CWL) is a specification for describing analysis workflows and tools in a way that makes them portable and scalable across a variety of software and hardware environments, from workstations to cluster, cloud, and high performance computing (HPC) environments. CWL is designed to meet the needs of data-intensive science, such as Bioinformatics, Medical Imaging, Astronomy, Physics, and Chemistry.
Cedar The Cedar language is a programming language derived from Mesa, which in turn is derived from Pascal. It is meant to be used for a wide variety of programming tasks, ranging from low level systems software to large applications. In addition to the sequential control constructs, static type checking and structured types of Pascal, and the modules, exception handling, and concurrency control constructs of Mesa, Cedar also has garbage collection, dynamic types, and a limited form of type parameterization.
ctalk-lang The CTalk programming language: a strategic evolution of APL
CSVw The CSV on the Web Working Group has developed standard ways to express useful metadata about CSV files and other kinds of tabular data.
circle-lang The C++ Automation Language
Boogie The Boogie IVL (intermediate verification language) is a simple language designed for verification which was originally created by Microsoft Research.
texti The Best of Markdown, Wikipedia Markup, LaTeX & Friends - All Together Now
Berkeley DB The Berkeley Database (Berkeley DB) is an embedded database system that can be used in applications requiring high-performance concurrent storage and retrieval of key/value pairs. The software is distributed as a library that can be linked directly into an application. It provides a variety of programmatic interfaces, including callable APIs for C, C++, Perl, Tcl and Java. Users may download Berkeley DB from Sleepycat Software’s Web site, at www.sleepycat.com.
Babylonian numerals The Babylonian system is credited as being the first known positional numeral system, in which the value of a particular digit depends both on the digit itself and its position within the number. Only two symbols (Babylonian 1.svg to count units and Babylonian 10.svg to count tens) were used to notate the 59 non-zero digits.
Business Object Notation The BON method for analysis and design of object-oriented software was developed 1989-93 by Jean-Marc Nerson and Kim Waldén as a means of extending the higher-level concepts of the Eiffel programming language into the realm of analysis and design aided by a graphical notation. The core idea is simplicity and well-defined semantics, since from our industrial experience we know that anything complex and/or ambiguous becomes useless in practice, and tends to be a hindrance rather than an aid to successful completion of software projects. In this respect, BON could be viewed as the direct opposite of the widely publicized UML/RUP approach.
arvelie-format The Arvelie Calendar has 26 months of 14 days each. Each month has 2 weeks of 7 days, and each month's name is one of the 26 letters of the alphabet. The 365th day of the year is the Year Day(+01), preceded by the Leap Day(+02) on leap years.
Arduino Programming Language The Arduino Programming Language is mostly C++ with
Liber Abaci The Arabic numeral system as presented in Liber Abaci.
A51 Assembly The A51 and A251 assembler translate programs you write in assembly language into executable machine instructions. You may use the A51 assembler to assemble programs for the 8051 family of microcontrollers.
1C Enterprise Script The 1C:Enterprise platform allows for business oriented application development. The software allows work in thick, thin and web clients.[21] It also supports creating mobile applications for Android and iOS in the same environment using the 1C programming language
Xmind Format The .xmind file format implementing XMind Workbooks consists of a ZIP compressed archive containing an XML document for contents, an XML document for styles, a .png image file for thumbnails, and some directories for attachments. The file format is open and based on some principles of OpenDocument/Office Open XML.
$ The $ language is the simplest form of functional programming, consisting as it does in the iterative application of a simple substitution rule on well-formed strings of the language.
plink-ped-format The "ped" file is a commonly used format for holding pedigree and genotype data. Files in this format usually end in ".ped". There are several variants of the format. Used by plink.
Terra Terra is a low-level system programming language that is embedded in and meta-programmed by the Lua programming language:
tao3d Tao3D is a programming language for interactive 3D.
Taichi Taichi Lang is an open-source, imperative, parallel programming language for high-performance numerical computation. It is embedded in Python and uses just-in-time (JIT) compiler frameworks, for example LLVM, to offload the compute-intensive Python code to the native GPU or CPU instructions.
TWiki TWiki's Wiki Syntax.
Trex TREX is a new language for validating XML documents. A TREX pattern specifies a pattern for the structure and content of an XML document. A TREX pattern thus identifies a class of XML documents consisting of those documents that match the pattern. A TREX pattern is itself an XML document.
TLA 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.
Type Language TL (Type Language) serves to describe the used system of types, constructors, and existing functions.
terse TERSE is an x86 specific programming language compatible with the entire processor family from the 8088 through the Pentium 4 and beyond. It is a machine-level language that gives you all of the control available in assembly language with the ease-of-use and the look-and-feel of a high-level language like C.
Homa TCP’s problems are too fundamental and interrelated to be fixed; the only way to harness the full performance potential of modern networks is to introduce a new transport protocol into the datacenter.
Culler-Fried System System for interactive mathematics by Glen Culler and Burton Fried of Thompson Ramo Wooldridge Inc.
highlight.js Syntax highlighting for the Web
svgbob Svgbob is a diagramming model which uses a set of typing characters to approximate the intended shape.
Svelte Svelte is a radical new approach to building user interfaces. Whereas traditional frameworks like React and Vue do the bulk of their work in the browser, Svelte shifts that work into a compile step that happens when you build your app. Instead of using techniques like virtual DOM diffing, Svelte writes code that surgically updates the DOM when the state of your app changes.
SuperForth SuperForth v1.1
sugarj SugarJ, a language on top of Java, SDF and Stratego, which supports syntactic extensibility.
Sublime Syntax Sublime Syntax files are YAML files with a small header, followed by a list of contexts. Each context has a list of patterns that describe how to highlight text in that context, and how to change the current text.
strudel Strudel is our graphical tool for visualizing genetic and physical maps of genomes for comparative purposes. The Strudel data format is tab delimited text with all features, homologs and potential reference URLs included in the same file.
Strongtalk Strongtalk is a major re-thinking of the Smalltalk-80 programming language and system. While retaining the basic Smalltalk syntax and semantics, it contains a number of significant advances.
Streem Streem is a stream based concurrent scripting language. It is based on a programming model similar to the shell, with influences from Ruby, Erlang, and other functional programming languages.
Strand Strand is a logic programming language designed for efficient programming of parallel computers.
storyscript Storyscript is a language, editor, database, infra and community all-in-one. Create holistic apps, tools and workflows blazing fast that power your business.
Stencil Stencil is a simple and powerful template language for Swift. It provides a syntax similar to Django and Mustache.
ASCII Started out as 7 bits. Now 8.
Mathpix Markdown Standard Markdown and extended it with key LaTeX features and chemistry support. Mathpix Markdown extends standard Markdown, for more power and control when converting your document to HTML, LaTeX, PDF, and DOCX.
spry Spry borrows homoiconicity from Rebol and Lisp, free form syntax from Forth and Rebol, the word of different types from Rebol, good data structure literal support from JavaScript and the general coding experience and style from Smalltalk. It also has a few ideas of its own, like an interesting argument passing mechanism and a relatively novel take on OO.
Spatial Spatial: A High Level Programming Language for FPGAs
Space Space is a lightweight language for objects. Space is like XML or JSON, with less punctuation and more power.
Sourcetree Sourcetree is a free graphical user interface (GUI) desktop client that simplifies how you interact with Git repositories so that you can fully concentrate on coding
bog Small, strongly typed, embeddable language.
Slony Slony-I is a "master to multiple slaves" replication system for PostgreSQL supporting cascading (e.g. - a node can feed another node which feeds another node...) and failover.
slim-pl Slim is a general-purpose programming language resembling SETL. It is more like a cousin to SETL than a child, since it shares a common heritage with SETL, but was independently designed.
Slideshow Slideshow is a library for creating presentation slides. Unlike Powerpoint, Slideshow provides no WYSIWYG interface for constructing slides. Instead, like Beamer, a presentation is generated by a program
skulpt Skulpt is an entirely in-browser implementation of Python.
Sitemap Sitemaps are an easy way for webmasters to inform search engines about pages on their sites that are available for crawling. In its simplest form, a Sitemap is an XML file that lists URLs for a site along with additional metadata about each URL (when it was last updated, how often it usually changes, and how important it is, relative to other URLs in the site) so that search engines can more intelligently crawl the site.
TMTP Site-specific Internet messaging
singular Singular is a computer algebra system for polynomial computations, with special emphasis on commutative and non-commutative algebra, algebraic geometry, and singularity theory.
Generic Haskell Since datatypes often change and new datatypes are introduced, we have developed Generic HASKELL which supports generic definitions to save the programmer from (re)writing instances of generic functions. Generic HASKELL extends the functional programming language Haskell [5] with, among other things, a construct for defining type-indexed values with kind-indexed types, based on recent work by Hinze [2]. These values can be specialised to all Haskell datatypes, facilitating wider application of generic programming than provided by earlier systems such as PolyP
Simplicity Simplicity is a work-in-progress low-level programming language with greater flexibility and expressiveness than Bitcoin Script. Simplicity is a typed, combinator-based, functional language without loops and recursion, designed to be used for crypto-currencies and blockchain applications.
SimCode SimCode is a C like description language. You use it to define the characteristics and behavior of the device you are modeling. It includes functions to define parameters such as propagation delays, load characteristics, strengths, and so on. The device behavior is defined using truth tables, math functions and conditional control statements, such as IF..THEN statements. Digital SimCode is a proprietary language - devices created with it are not compatible with other simulators, nor are digital components created for other simulators compatible with Altium Designer's Mixed-Signal Circuit Simulator.
shadama Shadama is the prototype of a programming language for writing programs that create, control and visualize large numbers of objects. The Shadama environment supports liveness, yet Shadama programs are run on the GPU, which enables high performance. The primary goal of the language is to facilitate the writing of scientific simulations by students at the high school level.
iScript Servertec has announced iScript, a platform independent scripting language written in Java, for creating scalable, server-side, object-oriented, n-Tier enterprise solutions. The iScript scripting language features platform independence, object-oriented architecture, web-server integration, support for Common Gateway Interface (CGI), dynamic content generator, static content preprocessor, make facility, just-in-time pcode generator and caching, Java API wrappers and open component API. Servertec will be releasing the iScript Developer Kit, which integrates the iScript scripting language, documentation and examples to the public. Web site developers can use this kit to create and maintain dynamic, data driven and static web sites. iScript preview release is available for free at http://www.servertec.com/. The final release of iScript is scheduled to ship in the second half of 1998. Final pricing details have yet to be announced.
Semantic Versioning Semantic versioning (aka SemVer)[1], currently the best known and most widely adopted version scheme in this category, uses a sequence of three digits (Major.Minor.Patch), an optional prerelease tag and optional build meta tag. In this scheme, risk and functionality are the measures of significance. Breaking changes are indicated by increasing the major number (high risk), new non-breaking features increment the minor number (medium risk) and all other non-breaking changes increment the patch number (lowest risk). The presence of a prerelease tag (-alpha, -beta) indicates substantial risk, as does a major number of zero (0.y.z), which is used to indicate a work-in-progress that may contain any level of potentially breaking changes (highest risk).
SRecode Template Semantic Recoder (or SRecode) is a template manager and code generator that is a part of CEDET.
sepi SePi is a concurrent, message-passing programming language based on the pi-calculus. The language features synchronous, bi-directional channel-based communication.
ScriptEase ScriptEase provides the most powerful and advanced form of JavaScript available today. Whereas other flavors of JavaScipt are embedded in web browsers and restricted to scripts that have been transmitted along with HTML documents, the ScriptEase processor allows you to run scripts locally, so you can use ScriptEase to write full fledged programs. In addition, ScriptEase has added commands and directives that increase and extend its power without interfering with the operation of standard JavaScript. These enhancements include preprocessor directives such as #include and #define, the switch/case statement, and the built-in Buffer object.
gentee Script programming language for automation. It uses VM and compiler written in Go (Golang).
Sclipting Sclipting is a stack-based golf language, inspired by GolfScript, that uses Chinese characters for instructions and Hangul syllables for data (strings and integers). The basic idea is that to minimise the number of characters in a program, the language should provide as many single-character instructions as possible. It was invented by Timwi in 2011. Sclipting is not considered finished as it can trivially be extended with more and more instructions assigned to new Chinese characters.
plink-fam-format Sample information file accompanying a .bed binary genotype table. The FAM file is just the first six columns of the PED file.
stx STx implements a powerful scripting language. This document will try to give you the necessary information to program your own applications. Scripts can be used to implement: simple processing lists, calling standard STx signal processing applications, signal processing application (like the Spectrogram & Parameters Viewer), complex database operations on the STx DataSet, in fact, everything you see in STx can be programmed in the macro language. The term STx script is a synonym for an application implemented using one or more STx macros, classes and SPU's, and executed by the script controller application BScript.
Statement List STL corresponds to the "Instruction List" language defined in the International Electrotechnical Commission's standard IEC 1131-3, although there are substantial differences with regard to the operations. STL corresponds to the Instruction List language defined in the IEC 61131-3 specification.
stella STELLA is a strongly typed, object-oriented, Lisp-like language, designed to facilitate symbolic programming tasks in artificial intelligence applications. STELLA preserves those features of Common Lisp deemed essential for symbolic programming such as built-in support for dynamic data structures, heterogeneous collections, first-class symbols, powerful iteration constructs, name spaces, an object-oriented type system with a meta-object protocol, exception handling, and language extensibility through macros, but without compromising execution speed, interoperability with non-STELLA programs, and platform independence. STELLA programs are translated into a target language such as C++, Common Lisp, or Java, and then compiled with the native target language compiler to generate executable code. The language constructs of STELLA are restricted to those that can be translated directly into native constructs of the intended target languages, thus enabling the generation of highly efficient as well as readable code. As of Fall 2000, we have programmed approximately 100,000 lines of STELLA code - about 50% for the STELLA kernel itself and the other 50% for the PowerLoom knowledge representation system and related systems. Our subjective experience has been that it is only slightly more difficult to write and debug a STELLA program than a Lisp program, and that the inconvenience of having to supply some type information is much outweighed by the benefits such as catching many errors during compile time instead of at run time. The biggest benefit, however, seems to be that we can still leverage all the incremental code development benefits of Lisp, since we use the Common Lisp-based version of STELLA for prototyping. This allows us to incrementally define and redefine functions, methods and classes and to inspect, debug and fix incorrect code on the fly. Even the most sophisticated C++ or Java IDE's don't yet seem to support this fully incremental development style, i.e., a change in a class (every change in Java is a change to a class) still requires recompilation and restart of the application, and it is the restart that can be the most time consuming if one debugs a complex application that takes a significant time to reach a certain state.
ssl-lang SSL (Software Specification Language) is a new formalism for the definition of specifications for software systems. The language provides a linear format for the representation of the information normally displayed in a two-dimensional module inter-dependency diagram. In comparing SSL to FORTRAN or ALGOL, it is found to be largely complementary to the algorithmic (procedural) languages. SSL is capable of representing explicitly module interconnections and global data flow, information which is deeply imbedded in the algorithmic languages. On the other hand, SSL is not designed to depict the control flow within modules. The SSL level of software design explicitly depicts intermodule data flow as a functional specification.
SQRL SQRL was the language designed by Smyte, and later acquired by Twitter in 2018. It is a safe, stateful language for event streams, designed to make it easy to enforce anti-abuse rules.
HiveQL SQL-like query language interface called the Hive query language. While based on SQL, HiveQL does not strictly follow the full SQL-92 standard. Internally, a compiler translates HiveQL statements into a directed acyclic graph of MapReduce, Tez, or Spark jobs, which are submitted to Hadoop for execution.
sina SINA is an object-oriented language for distributed and concurrent programming.
sile SILE is a typesetting system. Its job is to produce beautiful printed documents from raw content.
SIL SIL is an SSA-form IR with high-level semantic information designed to implement the Swift programming language. In contrast to LLVM IR, SIL is a generally target-independent format representation that can be used for code distribution, but it can also express target-specific concepts as well as LLVM can.
SETL SETL is a general-purpose, high-level programming language in which sets and first-order mappings are fundamental to the syntax and semantics of the language. This lends great conciseness and readability to a wide range of applications, from basic data filtering and transformation to the abstract presentation of complex algorithms. SETL is particularly good for software prototyping.
sdf-format SDF is an XML format that describes objects and environments for robot simulators, visualization, and control. Originally developed as part of the Gazebo robot simulator, SDF was designed with scientific robot applications in mind. Over the years, SDF has become a stable, robust, and extensible format capable of describing all aspects of robots, static and dynamic objects, lighting, terrain, and even physics.
Simple Binary Encoding SBE is an OSI layer 6 presentation for encoding and decoding binary application messages for low-latency financial applications. This repository contains the reference implementations in Java, C++, Golang, C#, and Rust
s-lang S-Lang is an interpreted language that was designed from the start to be easily embedded into a program to provide it with a powerful extension language. Examples of programs that use S-Lang as an extension language include the jed text editor and the slrn newsreader. Although S-Lang does not exist as a separate application, it is distributed with a quite capable program called slsh (``slang-shell'') that embeds the interpreter and allows one to execute S-Lang scripts, or simply experiment with S-Lang at an interactive prompt. Many of the the examples in this document are presented in the context of one of the above applications. S-Lang was originally a stack language that supported a postscript-like syntax. For that reason, I named it S-Lang, where the S was supposed to emphasize its stack-based nature. About a year later, I began to work on a preparser that would allow one unfamiliar with stack based languages to make use of a more traditional infix syntax. Currently, the syntax of the language resembles C, nevertheless some postscript-like features still remain, e.g., the `%' character is still used as a comment delimiter.
Script.NET S# is a weakly-typed dynamic language and runtime infrastructure to make your applications extendable, customizable and highly flexible.
RustScript RustScript: A simple functional based programming language with as much relation to Rust as JavaScript has to Java
runic Runic is a first order templating language operating on arrays of strings.
runescript RuneScript is a scripting language that Jagex uses to create content for RuneScape. The game engine is not written in RuneScript, but instead Java.
rosette-lang Rosette is a solver-aided programming language that extends Racket with language constructs for program synthesis, verification, and more. To verify or synthesize code, Rosette compiles it to logical constraints solved with off-the-shelf SMT solvers. By combining virtualized access to solvers with Racket’s metaprogramming, Rosette makes it easy to develop synthesis and verification tools for new languages.
Rockstar Rockstar is a dynamically typed Turing-complete programming language. Rockstar is designed for creating computer programs that are also song lyrics, and is heavily influenced by the lyrical conventions of 1980s hard rock and power ballads.
Violent ES Robust dialect of the EcmaScript scripting language. Not available yet, work in progress.
RoboTalk Robotalk: A New Language To Control The Rhino Robot.
rise Rise is a functional pattern-based language in the style of Lift. Rise provides a set of data-parallel high-level patterns that are used to describe computations over higher dimensional arrays (aka tensors) in an abstract way. For example, the map pattern applies a given function to every element of the input array. The zip pattern combines two input arrays pairwise to produce an output array of pairs. The reduce pattern is customized with a binary reduction operator (such as addition), a matching neutral element (such as zero), and an input array that is reduced to a single value (such as the sum of all elements).
Ripple Ripple is a programming language which is well designed for numerical simulations.
Rholang Rholang is an open and scalable blockchain language designed for speed, reliability and formal process orchestration build on latest research in the reflective high order process calculus.
RenderScript RenderScript is a component of the Android operating system for mobile devices that offers an API for acceleration that takes advantage of heterogeneous hardware. It allows developers to increase the performance of their applications at the cost of writing more complex (lower-level) code.
Ren-C Ren-C is a deeply redesigned LGPL 3.0-licensed derivative of the Rebol 3 codebase. It explores solutions to some of the Rebol language's longstanding open questions, adding fundamental new evaluation abilities and API embeddings.
Ren Ren is a lightweight data-exchange text format. It is programming language independent with familiar conventions. Whitespace separates values, but is not significant beyond that. Ren has two main data structures: An ordered group of values, called a list; A collection of name/value pairs, called a map
Google Cloud SQL Relational database management system (RDBMS) as a service
Amazon RDS Relational database management system (RDBMS) as a service
Teradata Relational database management system (RDBMS)
Oracle Relational database management system (RDBMS)
Microsoft SQL Server Relational database management system (RDBMS)
Microsoft Access Relational database management system (RDBMS)
InterBase Relational database management system (RDBMS)
IBM DB2 Relational database management system (RDBMS)
Apache Derby Relational database management system (RDBMS)
reforth Reforth tries to solve my gripes without fundamentally changing Forth's elegance and simplicity.
redpanda-app Redpanda is a queue for people who deal with massive data streams.
Real-Time Mentat Real-time Mentat, a programming environment designed to simplify the task of programming real-time applications in distributed and parallel environments, is described. It is based on the same data-driven computation model and object-oriented programming paradigm as Mentat.
Rescript ReScript is a robustly typed language that compiles to efficient and human-readable JavaScript. It comes with a lightning fast compiler toolchain that scales to any codebase size.
RATFOR Ratfor (short for Rational Fortran) is a programming language implemented as a preprocessor for Fortran 66. It provided modern control structures, unavailable in Fortran 66, to replace GOTOs and statement numbers.
Rascal Rascal solves this problem by integrating source code analysis, transformation, and generation primitives on the language level. Use it for any kind of metaprogramming task: to construct parsers for programming languages, to analyze and transform source code, or to define new DSLs with full IDE support. Rascal is a programming language; such that meta programs can be created by, understood by, and debugged by programmers.
rapidgen-rpl RapidGen translates the XML into a concise and transparent format of decision tables for decision logic programming —RPL— a rich, purpose-built language developed by the company. Supports high speed execution of decision models. Is capable of processing large data volumes. Preserves traceability to the original DMN model.
rainbow Rainbow is an implementation of Arc in Java. It is fairly complete, providing continuations and tail-call optimization.
Radish Radish Programming Language
Restricted Python RPython is a restricted subset of Python that is amenable to static analysis. RPython is a proper subset of Python, is statically typed, and does not allow dynamic modification of class or method definitions; however, it can still take advantage of Python features such as mixins and first-class methods and classes.
rosie RPL is a variant of modern Regular Expressions (regex) that is designed to scale to big data, many developers, and large collections of patterns. If you use regex, you already know a lot of RPL.
Reactive Plan Language RPL (Reactive Plan Language) belongs to the family of notations for writing reactive plans for agents (e.g., robots) (Davis 1984, Ingrand and George 1990, Lyons 1990a,b, Gat 1991). Its immediate ancestor is Firby's (1987, 1989) RAP notation. Many of Firby's concepts have been carried over, but there are some differences
root-format ROOT provides a file format that is a machine-independent compressed binary format, including both the data and its description, and provides an open-source automated tool to generate the data description (or "dictionary") when saving data, and to generate C++ classes corresponding to this description when reading back the data.
Ron RON is a simple readable data serialization format that looks similar to Rust syntax. It's designed to support all of Serde's data model, so structs, enums, tuples, arrays, generic maps, and primitive values.
RHTML RHTML is HTML mixed with Ruby, using HTML tags. All of Ruby is available for programming along with HTML.
relax RELAX (REgular LAnguage description for XML) is a specification for describing XML-based languages. XHTML 1.0, for example, can be described in RELAX. A description written in RELAX is called a RELAX grammar. An XML document can be verified against a RELAX grammar. Compared with DTD(Document Type Definition), RELAX has new features: RELAX grammars are represented in the XML instance syntax. RELAX borrows rich datatypes of XML Schema Part 2. RELAX is namespace-aware
REC Studio REC Studio is an interactive decompiler. It reads a Windows, Linux, Mac OS X or raw executable file, and attempts to produce a C-like representation of the code and data used to build the executable file. It has been designed to read files produced for many different targets, and it has been compiled on several host systems.
REALBasic (now Xojo) REALBasic is now known as Xojo.
Reuse Description Language RDL: A Language for Framework Instantiation Representation
rbasic RBASIC was an in-house language, written by Mike Welch of Hemet, California, in 1985, for Diversified Data Design (DDD), currently in Culver City, California, for use at DDD's customer Medi-Sec, formerly of Santa Monica, CA. DDD was run by Horace Clark at the time, Medi-Sec was run by Neal Green. RBASIC was a dialect of BASIC with an included relational database.
raptor RAPTOR is a flowchart-based programming environment, designed specifically to help students visualize their algorithms and avoid syntactic baggage.
rsharp R# is a free programming language based on REBOL.
Qunity Qunity: A Unified Language for Quantum and Classical Computing
grid-notation Quickly and easily create grids and manipulate guides with a consistent UI in Photoshop, Illustrator, Sketch, and Adobe XD.
quexal Quetzal (pronounced ket-sal) is a tangible programming language designed for children and novice programmers to control LEGO MINDSTORMS robots.
Quake Quake is a simple, specialized language and its interpreter drawing on elements of the C language, the Bourne shell, and the C pre-processor. The cm3 compiler includes a quake interpreter as its extension language. In fact, the configuration file, cm3.cfg, and m3makefiles are quake scripts. Quake was designed to be a simple extension language for the builder. Building a complete, general-purpose language was not one of the goals. Cm3 calls out to quake every time it needs to do something that needs to be specialized such as compiling C files or linking.
Quaint Quaint is a markup language that you can use to write documents. It is similar to Markdown, but it is more powerful and more extensible.
qbe QBE aims to be a pure C embeddable backend that provides 70% of the performance of advanced compilers in 10% of the code. Its small size serves both its aspirations of correctness and our ability to understand, fix, and improve it. It also serves its users by providing trivial integration and great flexibility.
Bython Python with braces. Because python is awesome, but whitespace is awful.
Python Format Specification Python minilang introduced in Python 2.6 in 2008.
pyret Pyret is a programming language designed to serve as an outstanding choice for programming education while exploring the confluence of scripting and functional programming. It's under active design and development, and free to use or modify.
Pygments Pygments is a generic syntax highlighter suitable for use in code hosting, forums, wikis or other applications that need to prettify source code.
Pycket Pycket: a Racket/Scheme implementation that is generated using the RPython framework
Pursuit PureScript Package Repository Pursuit hosts API documentation for PureScript packages.
carth Purely functional programming with lisp-syntax. Less infix, more parens!
Amazon DynamoDB Proprietary NoSQL cloud-based database management system
Project Mentat Project Mentat is a persistent, embedded knowledge base. It draws heavily on DataScript and Datomic. This project was started by Mozilla, but is no longer being developed or actively maintained by them.
Explorer Programs are encoded as TSVs so are easy to read+write from a spreadsheet IDE, code, or plain text editor.
txr Programming Language for Convenient Data Munging
soul Program queries can answer important software engineering questions ranging from “is my code bug free?” over “does my code follow the prescribed design?” to “how can my code be refactored?”. SOUL is a Prolog-like language with specialized features for querying programs.
nianiolang Procedural programming language without pointers
ProVerif ProVerif is an automatic cryptographic protocol verifier, in the formal model (so called Dolev-Yao model).
Prism Prism is a lightweight, extensible syntax highlighter, built with modern web standards in mind. It’s used in millions of websites, including some of those you visit daily.
plink-bed-format Primary representation of genotype calls at biallelic variants. Do not confuse this with the UCSC Genome Browser's BED format, which is totally different. Used in plink.
LinkText Preview of LinkText, A Data Modeling Language
Marp Presentations in markdown
manool Practical programming language with expressive power, in 10 KLOC in C++11 - "MAnool is Not an Object-Oriented Language!"
Potion Potion is an object- and mixin-oriented (traits) language.
PostScript Postscript is a graphical page description language invented by ChuckGetsche and JohnWarnock (the President and CEO of Adobe). Its syntax looks a little bit like Forth, because it is derived from Forth; however, Postscript's internal implementation has nothing to do with Forth.
polymath Polymath is a markup language (like Markdown, LaTeX, or HTML) and a static site generator specialized in aesthetically presenting a wide variety of information: text, mathematics, code, photos, videos, you name it.
Planguage Planguage is a keyword-driven language whose name is derived from a contraction of the words planning and language1. Planguage can be used in requirements specifications, design documents, plans, and other places where qualitative statements are common. Its primary benefits are quantifying the qualitative and improving communication about complex ideas
pikelet Pikelet is a small, functional, dependently typed programming language.
pie-lang Pie: A Little Language with Dependent Types. Pie is a Racket language, requiring Racket version 6.5 or newer.
piccola Piccola is a small, pure language for building applications from software components. Piccola is small in the sense that its syntax is tiny, and it is pure in the sense that it provides only compositional features — computation is performed entirely by components of the host programming language. The semantics of Piccola is defined in terms of a process calculus, an extension of Milner’s pi calculus in which values communicated are forms, rather than tuples. A "form" is essentially an extensible nested record which also serves as a namespace in which expressions may be evaluated. This simple mechanism is responsible for much of the expressive power of Piccola.
Pharo Pharo is a pure object-oriented programming language and a powerful environment, focused on simplicity and immediate feedback (think IDE and OS rolled into one).
PgBouncer PgBouncer is an open-source, lightweight, single-binary connection pooler for PostgreSQL. It can pool connections to one or more databases (on possibly different servers) and serve clients over TCP and Unix domain socket.
Peridot Peridot MVP
Pascal Script Pascal Script is a free scripting engine that allows you to use most of the Object Pascal language within your Delphi or Free Pascal projects at runtime. Written completely in Delphi, it is composed of a set of units that can be compiled into your executable, eliminating the need to distribute any external files. Pascal Script started out as a need for a good working script, when there were none available at the time.
parasail ParaSail is a new parallel programming language designed to support the development of inherently safe and secure, highly parallel applications that can be mapped to multicore, manycore, heterogeneous, or distributed architectures.
Papyrus Papyrus is an entirely new scripting system created specifically for the Creation Kit. If you've never used a Bethesda toolset before, consider some basic tutorials to get your footing with the Creation Kit in general.
panther-lang Panther is a programming language aimed at young users with only a small knowledge of programming. Panther offers you a more advanced version of Scratch, a simple programming language developed at MIT.
PTX PTX, a low-level parallel thread execution virtual machine and instruction set architecture (ISA). PTX exposes the GPU as a data-parallel computing device.
PRQL PRQL is a modern language for transforming data — a simple, powerful, pipelined SQL replacement
PLZ PLZ/SYS is intended to aid the implementation of system programs for microcomputers. PLZ/SYS is a synthesis of concepts from contemporary programming languages and compilers--the language Pascal has had the most notable influence on the overall design and implementation of PLZ/SYS.
PEG.js PEG.js is a simple parser generator for JavaScript that produces fast parsers with excellent error reporting. You can use it to process complex data or computer languages and build transformers, interpreters, compilers and other tools easily.
P* P* (pronounced P-star) is a programming language specifically designed for web development. P* provides easy in-language support for common tasks in this field.
P P is a state machine based programming language for modeling and specifying complex distributed systems.
Oxyl Oxyl is a functional programming language focused on being explicit and safe but not clunky or verbose
Oxide Oxide, scripting language with Rust-influenced syntax
Org Org is a mode for keeping notes, maintaining TODO lists, and project planning with a fast and effective plain-text system. It also is an authoring system with unique support for literate programming and reproducible research.
orca-lang Orca is a REBOL-like interpreter which can be used under the terms of either the GPL or LGPL. The interpreter is a C library so that C/C++ applications can use Orca as an embedded scripting system.
orange Orange is a systems programming language made to be as powerful as C++ with none of the headache. It aims to be very productive by baking the most important low- and high-level features directly into the language, instead of dealing with them through obtuse function calls.
operon Operon.io is a powerful language to query, transform and integrate JSON-data. You can use it for example to build a small microservice for your backend services. All code is run on the powerful and battle tested Java Virtual Machine (JVM).
OpenSpice OpenSpice is an openly available specification of the Spice language - a modern programming language with some nice XML processing features. It is designed with the needs of part-time or occasional programmers in mind. The language features are properly separated and their corner cases have been eliminated. This design means that if you only use Spice occasionally, you're likely to find it easy to come back to despite the breaks. The most similar well-known language is probably Common LISP together with CLOS. But Spice has a rich Algol-like external syntax, an XML transport form, and makes multiple values a key feature. The way Spice deals with multiple values is, we think, the feature that will strike most programmers as special.
OpenSCAD OpenSCAD is a 2D/3D and solid modeling program which is based on a Functional programming language used to create models that are previewed on the screen, and rendered into 3D mesh which allows the model to be exported in a variety of 2D/3D file formats. A script in the OpenSCAD language is used to create 2D or 3D models. This script is a free format list of action statements.
OpenRC runscript OpenRC is basically an interpreter for shell scripts which provides an easy interface to the often complex system commands and daemons. When a service runs a command it first loads its multiplexed configuration file, then its master configuration file, then /etc/rc.conf and finally the script itself. At this point then runs the command given.
ASCII Armor OpenPGP provides the service of converting the raw 8-bit binary octet stream to a stream of printable ASCII characters, called Radix-64 encoding or ASCII Armor.
dsym On Apple platforms, debug symbols are optionally emitted during the build process as dSYM file(s). Apple uses the term "symbolicate" to refer to the replacement of addresses in diagnostic files with human readable values. If you are distributing your app via the App Store, or conducting a beta test using Test Flight, you will be given the option of including the dSYM file when uploading your archive to iTunes Connect. In the submission dialog, check “Include app symbols for your application…”. Uploading your dSYM file is necessary to receive crash reports collected from TestFlight users and customers who have opted to share diagnostic data.
Omega Omega is a general purpose problem solving language with an informal conversational interface. Like pure functional programming languages, It is declarative and side-effect free. It is a pure calculus of types where each type characterizes a category of things. Omega expands the range of applications of automated systems by validly characterizing and answering questions about anything that can be imagined including infinite, incompletely knowable and nonexistent things.
oil Oil is a new Unix shell.
Ohayo Ohayo is a fast and free tool for data science. Ohayo consists of a very high level programming language and a visual web studio for that language. The goal of Ohayo is to enable people to do data science at the speed of voice.
oforth Oforth is an imperative, dynamic typed, stack-based language. Oforth is a Forth dialect (Oforth is for Object + Forth). It keeps Forth mecanisms while implementing a full object model.
Objective C++ Objective-C++ is simply source code that mixes Objective-C classes and C++ classes.
InterSystems Caché Object-oriented database management system
OOPS OOPS: A Knowledge Representation Language
OMNITAB 80 OMNITAB 80 is a high-level statistical analysis program. OMNITAB, the precursor of Minitab(TM), was developed in the Statistical Engineering Division and is maintained by the Statistical Engineering Division. OMNITAB performs many different statistical analyses including: arithmetic and trigonometric calculations, and matrix and array operations. The software responds to simple instructions and uses reliable computational algorithms.
O-Matrix O-Matrix is a matrix programming language for mathematics, engineering, science, and financial analysis, marketed by Harmonic Software. The language is designed for use in high-performance computing.
Numba Numba is an open source JIT compiler that translates a subset of Python and NumPy code into fast machine code.
Luna Now called Enso.
Note Note is a structured, human readable, concise language for encoding data.
none None (a backronym for None's Only Nested Expressions), also called Nonelang for clarity, is a young, powerful, convenient, extensible and performant programming language and infrastructure. It is developed alongside our game in production, NOWHERE (we have a Patreon going if you would like to support us).
noms-db Noms is a decentralized database philosophically descendant from the Git version control system.
Couchbase Mobile NoSQL document-oriented database management system for mobile devices
Couchbase NoSQL document-oriented database management system
Nim Nim was called Nimrod until 2014. Nimrod is a relatively new programming language that is severely underrated in comparison to other new programming languages, with extensive metaprogramming support, generics and exception tracking built in, optional garbage collection, and rivals C in performance. And it can compile to C, C++, Objective-C, or JavaScript. Nimrod is a statically typed, imperative programming language that tries to give the programmer ultimate power without compromises on runtime efficiency. This means it focuses on compile-time mechanisms in all their various forms.
newclay Newclay is an experimental offshoot of the Clay programming language. The Newclay compiler requires Clay to compile.
Sheep New scripting/querying/ipc/programming language I created for Amiga Inc. There is no publicly available material right now, except for an introductory article at Amiga World, an interview at OSNews.com, and this released screenshot of an early sheep beta in action: SHEEP was planned to have familiar beginner friendly syntax and semantics coupled with multimethods, automatic memory management without garbage collection (linearity), powerful datatypes, pattern matching, strong and dynamic typing living together in harmony, integrated access to all the new Amiga OS features, and optional compiled output comparable to C in speed and size.
NSS Native Structured Storage (NSS) was a method to transparently store ActiveX document files in a multi-stream format on NTFS volumes
TeaSharp My new programming language, TeaSharp
McLeyvier Command Language Music language
Multihash Multihash is a protocol for differentiating outputs from various well-established hash functions, addressing size + encoding considerations. It is useful to write applications that future-proof their use of hashes, and allow multiple hash functions to coexist.
OrientDB Multi-model NoSQL database management system
Microsoft Azure Cosmos DB Multi-model NoSQL database management system
ArangoDB Multi-model NoSQL database management system
MINI OBJECT-ORIENTED LANGUAGE Mool is a mini object-oriented language in a Java-like style with support for concurrency, that allows programmers to specify class usage protocols as types.
Mojo Mojo combines the usability of Python with the performance of C, unlocking unparalleled programmability of AI hardware and extensibility of AI models.
dlvm Modern Compiler Infrastructure for Deep Learning Systems
mochi Mochi is a dynamically typed programming language for functional programming and actor-style programming. Its interpreter is written in Python3. The interpreter translates a program written in Mochi to Python3's AST / bytecode.
aretext Minimalist text editor with vim-compatible key bindings.
Mindsdb MindsDB ML-SQL Server enables machine learning workflows for the most powerful databases and data warehouses using SQL.
order Metalanguage for C Preprocessor Metaprogramming
Metalang99 Metalang99: A functional language for C99 preprocessor metaprogramming
Melody Melody - A language that compiles to regular expressions and aims to be more easily readable and maintainable
Mech Mech is a language for developing data-driven, reactive systems like animations, games, and robots. It makes composing, transforming, and distributing data easy, allowing you to focus on the essential complexity of your problem.
Maude Maude is a high-level language and high-performance system supporting both equational and rewriting logic computation for a wide range of applications.
mathics Mathics is a free, general-purpose online computer algebra system featuring Mathematica-compatible syntax and functions. It is backed by highly extensible Python code, relying on SymPy for most mathematical tasks.
Teradata Aster Massively parallel processing (MPP) database management system
Greenplum Massively parallel processing (MPP) database management system
Markdeep Markdeep is a technology for writing plain text documents that will look good in any web browser, whether local or remote. It supports diagrams, calendars, equations, and other features as extensions of Markdown syntax.
Margin Margin is a lightweight markup language for hierarchically structured thought, like notes and to-do lists.
mal Mal is a Clojure inspired Lisp interpreter. Mal is implemented in 75 languages.
Mako Mako is a template library written in Python. It provides a familiar, non-XML syntax which compiles into Python modules for maximum performance. Mako's syntax and API borrows from the best ideas of many others, including Django and Jinja2 templates, Cheetah, Myghty, and Genshi. Conceptually, Mako is an embedded Python (i.e. Python Server Page) language, which refines the familiar ideas of componentized layout and inheritance to produce one of the most straightforward and flexible models available, while also maintaining close ties to Python calling and scoping semantics. Mako is used by reddit.com where it delivers over one billion page views per month. It is the default template language included with the Pylons and Pyramid web frameworks.
Sugar Makes JavaScript development sweeter !
Make Make — a program for maintaining computer programs
Markwhen Make a cascading timeline from Markdown-like text.
Magit Magit is a complete text-based user interface to Git. It fills the glaring gap between the Git command-line interface and various GUIs, letting you perform trivial as well as elaborate version control tasks with just a couple of mnemonic key presses
Project MAC’s SYmbolic MAnipulator Macsyma (Project MAC’s SYmbolic MAnipulator[1]) is one of the oldest general purpose computer algebra systems which is still widely used. It was originally developed from 1968 to 1982 at MIT's Project MAC.
mimix-stream-language MSL is built from Lisp style s-expressions. MSL differs from Lisp in the way it processes functions and arguments, so Lisp expressions cannot be directly included inside MSL nor vice-versa. MSL code can only contain other MSL.
MOOSE MOOSE is a Maisie-based Object-Oriented Simulation Environment that uses inheritance to support iterative design of efficient simulation models. The novel features of MOOSE include its ability to describe complex guards that may be used by an object to specify dynamic enabling conditions for its methods and may also be inherited selectively by a derived object. MOOSE is the first simulation environment to suggest the use of inheritance in driving parallel implementations of an object that may exploit specific knowledge about the application, architecture, or simulation algorithm to improve its efficiency. The paper introduces object-oriented design of simulation models, gives an overview of MOOSE, and illustrates its use in the design of parallel simulation models. Experimental results are provided on the speedup achieved by a parallel simulation of a simple stochastic benchmark.
Module Management System MMK is similar in functionality to Digital's DEC/Module Management System (MMS), and understands a syntax in its description files which is a superset of that which is understood by MMS.
mir MIR is a human readable serialization format that is used to represent LLVM’s machine specific intermediate representation. The MIR serialization format uses a YAML container.
MDX MDX allows you to use JSX in your markdown content. You can import components, such as interactive charts or alerts, and embed them within your content.
MAXScript MAXScript is the built-in scripting language in Autodesk 3ds MAX. It can be used to automate repetitive tasks as well as develop new tools and user interfaces.
M4Sugar M4 by itself provides only a small, but sufficient, set of all-purpose macros. M4sugar introduces additional generic macros. Its name was coined by Lars J. Aas: “Readability And Greater Understanding Stands 4 M4sugar”
Lush Lush is an object-oriented programming language designed for researchers, experimenters, and engineers interested in large-scale numerical and graphic applications. Lush is designed to be used in situations where one would want to combine the flexibility of a high-level, weakly-typed interpreted language, with the efficiency of a strongly-typed, natively-compiled language
Luna Luna is an expressive, minimalistic, elegant programming language implemented in C. With cooperative thread concurrency at its core, async I/O, and influences derived from languages such as Lua, io, Rust, Ruby, and C. Luna favours unification and minimalism over minor obscure conveniences, providing the true convenience of a simple effective language. This includes omitting features which facilitate magic such as getters/setters, method_missing-style delegation etc. This project is very much a work in progress, as I explore the wonderful world of VMs! feel free to join.
luau Luau is a fast, small, safe, gradually typed embeddable scripting language derived from Lua. It is used by Roblox game developers to write game code, as well as by Roblox engineers to implement large parts of the user-facing application code as well as portions of the editor (Roblox Studio) as plugins.
Lorel Lorel Query Language for Semistructured Data
Loom Loom is a language and environment for constructing intelligent applications. The heart of Loom is a knowledge representation system that is used to provide deductive support for the declarative portion of the Loom language. Declarative knowledge in Loom consists of definitions, rules, facts, and default rules. A deductive engine called a classifier utilizes forward-chaining, semantic unification and object-oriented truth maintainance technologies in order to compile the declarative knowledge into a network designed to efficiently support on-line deductive query processing.
Lola-2 Lola-2: A Logic Description Language. Lola is a notation (language) for specifying digital circuits (logic). In many ways it resembles a programming language. However, Lola texts describe static circuits rather than dynamic processes. Objects occurring in a description can be variables representing signals or registers. Their values are defined as expressions of other objects and operators representing gates.
Logos Logos is a component of the Theos development suite that allows method hooking code to be written easily and clearly, using a set of special preprocessor directives. Theos is a cross-platform suite of development tools for managing, developing, and deploying iOS software without the use of Xcode. It is an important tool for people building extensions (tweaks) for jailbroken iOS; most extension developers use Theos.
Logica Logica is an open source declarative logic programming language for data manipulation. Logica is a successor to Yedalog, a language created at Google earlier.
local LoCal: A Language for Programs Operating on Serialized Data
Makefile Lines that begin with TAB are assumed to be part of a recipe (so they are shell scripts and passed to the shell for parsing), and lines that do not begin with TAB cannot be part of a recipe (so they cannot be shell scripts: they must be make syntax).
Lil Lil is part of the technology that powers Decker, a multimedia creative tool inspired by HyperCard. Decker uses Lil for adding custom behavior to decks and the widgets within. Lil is designed to be learned in layers, but it is a richly multi-paradigm language which incorporates ideas from imperative, functional, declarative, and vector-oriented languages.
Lazy K Lazy K is a garbage-collected, referentially transparent functional programming language, with a simple stream-based I/O system. What distinguishes Lazy K from other such languages is its almost total lack of other features.
Lawvere Lawvere - a categorical programming language with effects
Please Build Language for the please.build cross-language build system. The Please build language is a full programming language.
Language for Your Remote Instruction by Computer Language for Your Remote Instruction by Computer.
Lambda Diagrams Lambda Diagrams are a graphical notation for closed lambda terms, in which abstractions (lambdas) are represented by horizontal lines, variables by vertical lines emanating down from their binding lambda, and applications by horizontal links connecting the leftmost variables. In the alternative style, applications link the nearest deepest variables, for a more stylistic, if less uniform, look.
lain Lain is both an inline scripting library that allows for complex templating of the wiki pages, and a programming language that exists at the core of the engine to load and parse content for each article.
Logres LOGRES is a new project for the development of extended database systems which is based on the integration of the object-oriented data modelling paradigm and of the rule-based approach for the specification of queries and updates. The data model supports generalization hierarchies and object sharing, the rule-based language extends Datalog to support generalized type constructors (sets, multisets, and sequences), rule-based integrity constraints are automatically produced by analyzing schema definitions. Modularization is a fundamental feature, as modules encapsulate queries and updates, when modules are applied to a LOGRES database, their side effects can be controlled. The LOGRES project is a follow-up of the ALGRES project, and takes advantage of the ALGRES programming environment for the development of a fast prototype.
lmdb LMDB is a Btree-based database management library modeled loosely on the BerkeleyDB API, but much simplified. The entire database is exposed in a memory map, and all data fetches return data directly from the mapped memory, so no malloc's or memcpy's occur during data fetches. As such, the library is extremely simple because it requires no page caching layer of its own, and it is extremely high performance and memory-efficient. It is also fully transactional with full ACID semantics, and when the memory map is read-only, the database integrity cannot be corrupted by stray pointer writes from application code.
lllpg LLLPG is a recursive-decent LL(k) parser generator for C# that generates efficient code and integrates with Visual Studio.
Low Level Lisp LLL is one of the original Ethereum smart contract programming languages and provides a different perspective and programming discipline when compared to the ubiquitous Solidity language. Lisp Like Language (LLL) is a low level language similar to Assembly. It is meant to be very simple and minimalistic; essentially just a tiny wrapper over coding in EVM directly.
LES LES is an interchange format for syntax trees, comparable to s-expressions but designed for languages in the Algol family such as C, C++, C#, Java, EcmaScript, Rust and Python. It can be described as “JSON for code”: just as XML/YAML/JSON are tree structures that assign no particular meaning to the data inside, likewise LES represents syntax trees without assigning any particular meaning to them.
lav-format LAV is a plain-text file format for alignments of two DNA sequences. It is the only output format produced by the BLASTZ alignment program (though often converted to AXT format by post-processing programs), and is the default output format for BLASTZ's successor, LASTZ.
LARP LARP is an educational software for teaching algorithmic in structured programming using pseudo code and flowcharts. LARP's main advantage over traditional programming languages is its flexible and semi natural syntax, allowing one to formulate algorithms without the impediments of cryptic languages such as C++, Pascal or Java.
kumir KuMir, which is used in some Russian schools for education. KuMir" is a game of words, literally “Kumir" means “Idol", but developers of this language say that this is abbreviature: “K" - Set, “u" - of Educational, “Mir" - WORLDs (КуМир - Комплект Учебных МИРов).
Konna Konna, my programming language
kona Kona is the open-source implementation of the k3 programming language. k is a synthesis of APL and LISP. Although many of the capabilities come from APL, the fundamental data construct is quite different. In APL the construct is a multi-dimensional matrix-like array, where the dimension of the array can range from 0 to some maximum (often 9). In k, like LISP, the fundamental data construct is a list. Also, like LISP, the k language is ASCII-based, so you don't need a special keyboard.
kogut Kogut is an experimental programming language which supports impurely functional programming and a non-traditional flavor of object-oriented programming. Its semantics is most similar to Scheme or Dylan, but the syntax looks more like ML or Ruby.
Knowledge Acquisition and Representation Language Knowledge Acquisition and Representation Language
kilo-lisp Kilo LISP is a small interpreter for purely symbolic LISP. Its source consists of 25K bytes of comprehensible code (20KB C, 5KB LISP) and it runs in 64K bytes of memory. None the less it offers: lexical scoping, tail call elimination, macros, quasiquotation, variable-argument functions, constant-space garbage collection, image files, keyboard interrupt handling
klisp Kilo LISP is a small interpreter for purely symbolic LISP. Its source consists of 25K bytes of comprehensible code (20KB C, 5KB LISP) and it runs in 64K bytes of memory.
KiCad Legacy Layout KiCad writes all files in human readable ASCII. This makes manipulation by hand and scripting very easy.
kernel Kernel is a conservative, Scheme-like dialect of Lisp in which everything is a first-class object.
kerf Kerf is a columnar tick database and time-series language for Linux/OSX/BSD/iOS/Android. It is written in C and natively speaks JSON and SQL. Kerf can be used for trading platforms, feedhandlers, low-latency networking, high-volume analysis of realtime and historical data, logfile processing, and more.
kayia Kayia is a way to construct a “declarative reactive” language based on a labeled, directed graph of edges. The excitement that I have with Kayia is that I think it has the potential to give software construction “the arch”, or that missing abstraction mechanism that has been holding it back. That’s a bold statement but I am attempting to prove that, because of its ability to start from such fine elements, simply A|B, and its capacity to manage yet not obstruct constructions of those elements, we can get higher-resolution constructions with greater control at the same time.
kaukatcr Kaukatcr (pronounced “cowcatcher”[3]) is a stack-based language modeled loosely on Forth. It avoids tokenization by treating cell boundaries as word boundaries. Like Forth, any word that is neither a built-in nor found in the dictionary of defined functions will be treated as data and pushed onto the stack.
Birkbeck Assembly Kathleen Booth née Britten (1922 –) wrote the first assembly language and designed the assembler and autocode for the first computer systems at Birkbeck College, University of London.
kate-editor Kate is a multi-document editor part of KDE since release 2.2. Being a KDE application, Kate ships with network transparency, as well as integration with the outstanding features of KDE. Choose it for viewing HTML sources from konqueror, editing configuration files, writing new applications or any other text editing task. You still need just one running instance of Kate.
Kal Kal is a highly readable, easy-to-use language that compiles to JavaScript.
kaitai Kaitai Struct is a YAML-based declarative language used to describe various binary data structures, laid out in files or in memory: i.e. binary file formats, network stream packet formats, etc. The main idea is that a particular format is described in Kaitai Struct language (.ksy file) and then can be compiled with ksc into source files in one of the supported programming languages. These modules will include a generated code for a parser that can read described data structure from a file / stream and give access to it in a nice, easy-to-comprehend API.
K K is like APL, but K restricts itself to the ASCII character set.
Just Just: A language like Make except not a build system
Jule Jule is the simple, efficient, statically typed and compiled system programming language.
Flow Javascript with static type checking.
Jasmin Jasmin is an assembler for the Java Virtual Machine. It takes ASCII descriptions of Java classes, written in a simple assembler-like syntax using the Java Virtual Machine instruction set. It converts them into binary Java class files, suitable for loading by a Java runtime system.
Jakt Jakt is a memory-safe systems programming language. It currently transpiles to C++.
JACL Jacl, pronunced “Jackal”, is a Tcl interpreter written in Java. You can use it for Java the same way Tcl is used for C — a scripting language to glue together modules written in a low level language.
Joyfully Universal Language for (Inline) Assembly JULIA is an intermediate language that can compile to various different backends (EVM 1.0, EVM 1.5 and eWASM are planned). Because of that, it is designed to be a usable common denominator of all three platforms. It can already be used for “inline assembly” inside Solidity and future versions of the Solidity compiler will even use JULIA as intermediate language. It should also be easy to build high-level optimizer stages for JULIA.
json->url JSON→URL is a language-independent data interchange format for the JSON data model suitable for use within a URL/URI query string. It is defined by an open specification, though not through a standards body.
JSON-stat JSON-stat is a simple lightweight JSON dissemination format best suited for data visualization, mobile apps or open data initiatives, that has been designed for all kinds of disseminators.
JSON Schema JSON Schema is a vocabulary that allows you to annotate and validate JSON documents.
JSON Lines JSON Lines is a convenient format for storing structured data that may be processed one record at a time. It works well with unix-style text processing tools and shell pipelines. It's a great format for log files. It's also a flexible format for passing messages between cooperating processes.
jsil-compiler JSIL is a compiler that transforms .NET applications and libraries from their native executable format - CIL bytecode - into standards-compliant, cross-browser JavaScript.
JSFuck JSFuck is an esoteric and educational programming style based on the atomic parts of JavaScript. It uses only six different characters to write and execute code.
JFlex JFlex is a lexical analyzer generator (also known as scanner generator) for Java, written in Java.
datafun It's a simple, pure, and total functional language that generalizes Datalog. Datafun's superpower is that it can concisely and declaratively express and compute fixed points of monotone maps on semilattices.
Soulver It's a notepad that gives instant answers to calculations in your text.
checkout It is designed to be lower-level than assembler or even machine code, by matching the way modern processors work more closely than machine language does (machine code matches the way processors used to work decades ago, rather than the way they work nowadays). Thus, it makes operations like memory transfers (which take up the most time on a modern processor) explicit; this leads to the language's name, as memory needs to be "checked out" via copy or move instructions in order to be able to use it. The secondary effect of this is that efficient code tends to be shorter and simpler than inefficient code, although it can sometimes be harder to see how it works.
pikachu It is an eso language designed specifically to be usable by Pikachus.
IBM Informix-4GL It includes embedded SQL, a report writer language, a form language, and a limited set of imperative capabilities (functions, if and while statements, and supports arrays etc.). The language is particularly close to a natural language and is easy to learn and use.
Isabelle Isabelle is a generic proof assistant. It allows mathematical formulas to be expressed in a formal language and provides tools for proving those formulas in a logical calculus. Isabelle was originally developed at the University of Cambridge and Technische Universität München, but now includes numerous contributions from institutions and individuals worldwide.
Invisible XML Invisible XML is a language for describing the implicit structure of data, and a set of technologies for making that structure explicit as XML markup. It allows you to write a declarative description of the format of some text and then leverage that format to represent the text as structured information.
Scheme 2-D Introducing the future of Scheme...take your S-expressions to the next level with Scheme 2-D!
MiKe Introducing MiKe: Constant-time control flow, automatic serialization, and more!
Integrated Data Store Integrated Data Store (IDS) was an early network database management system largely used by industry, known for its high performance. IDS became the basis for the CODASYL Data Base Task Group standards.
ink Ink is inkle's scripting language for writing interactive narrative, both for text-centric games as well as more graphical games that contain highly branching stories.
Megaparsec Industrial-strength monadic parser combinator library
SAP HANA In-memory relational database management system (RDBMS)
StoneCutter In this work we introduce the StoneCutter instruction set design language and tool infrastructure. StoneCutter provides a familiar, C-like language construct by which to develop the implementation for individual, programmable instructions. The LLVM-based StoneCutter compiler performs individual instruction and whole-ISA optimizations in order to generate a high performance, Chisel HDL representation of the target design. Utilizing the existing Chisel tools, users can also generate C++ cycle accurate simulation models as well as Verilog representations of the target design. As a result, StoneCutter provides a very rapid design environment for development and experimentation.
PAMELA In this report we present a new methodology for the performance prediction of parallel programs on parallel platforms ranging from shared-memory to distributed-memory (vector) machines. The complete methodology comprises the concurrent language Pamela (PerformAnce ModEling LAnguage), the program and machine modeling paradigm, and a novel performance analysis method, called "serialization analysis". While Pamela models can be directly executed (i.e., simulated), prior to this ultimate evaluation step, serialization analysis allows for (symbolic) model reduction, which often renders simulation superuous. This analysis method extends conventional parallel program analysis technology by explicitly accounting for the performance degrading e ects of resource contention, yet at the low evaluation cost, typical for conventional techniques. It is shown that, where application of conventional techniques may yield serious errors, predictions from serialization analysis remain accurate. Apart from the modeling methodology itself, this low-cost/high-reliability analysis potential makes Pamela a particularly suitable candidate for compile-time application in terms of the performance prediction hierarchy often found in parallel programming environments.
floorplan In this paper we introduce Floorplan, a declarative language for specifying memory layouts at a high level. Constraints formerly implemented by describing how to compute locations are, in Floorplan, defined declaratively using explicit layout constructs.
gnu-rtl In GCC, RTL is generated from the GIMPLE representation, transformed by various passes in the GCC 'middle-end', and then converted to assembly language.
ColorForth In Forth, a new word is defined by a preceding colon, words inside a definition are compiled, outside are executed. In colorForth a new word is red, green words are compiled, yellow executed. This use of color further reduces the syntax, or punctuation, needed. It also makes explicit how the computer will interpret each word.
BBx In 1985, BASIS released their first generation of Business BASIC to extend the functionality of Business BASIC and aptly named it BBx® (Business BASIC eXtended). Successive generations of BASIS technology continue to enhance the Business BASIC language. A fifth generation product delivers BASIS' first GUI deployment, followed by the sixth generation that introduces modern graphical application development tools for Business BASIC. Coupling these tools with a powerful database management system enable developers to create comprehensive and tightly integrated business applications that are reliable, scalable, cost-effective, and platform independent. Computer programs and associated documentation providing tools and programming language to enable software developers to create and prepare business, internet, and applications software Scientific, nautical, surveying, photographic, cinematographic, optical, weighing, measuring, signalling, checking (supervision), life-saving and teaching apparatus and instruments; apparatus and instruments for conducting, switching, transforming, accumulating, regulating or controlling electricity; apparatus for recording, transmission or reproduction of sound or images; magnetic data carriers, recording discs; automatic vending machines and mechanisms for coin operated apparatus; cash registers, calculating machines, data processing equipment and computers; fire extinguishing apparatus.
Liso Implemention of O-Expressions idea in Racket.
rockstar-rkt Implementation of Rockstar in Racket.
Imba Imba is a Web programming language that's fast in two ways: Imba's time-saving syntax with built-in tags and styles results in less typing and switching files so you can build things fast. Imba's groundbreaking memoized DOM is an order of magnitude faster than virtual DOM libraries, so you can build fast things.
Pandoc If you need to convert files from one markup format into another, pandoc is your swiss-army knife.
idyll Idyll is a markup language and toolkit for writing interactive articles. Idyll's reactive document model and standard component library decrease the amount of code needed to create high quality multimedia narratives. Idyll uses web standards to produce output that will load quickly in any web browser and is fully extensible. Idyll enables collaboration between programmers and journalists, researchers and designers. Those familiar with JavaScript can write custom components using tools like D3 or React.
ISO 8601 ISO 8601 is an international standard covering the worldwide exchange and communication of date and time-related data
Industrial Modeling and Programming Language IMPL is both a structure- and semantic-based machine-coded proprietary software language (closed-source) built upon the computer programming language Fortran to model and solve large-scale discrete, nonlinear and dynamic (DND) optimization and estimation problems found in the batch and continuous process industries such as oil and gas, petrochemicals, specialty and bulk chemicals, pulp and paper, energy, agro-industrial, mining and minerals, food and beverage just to name a few. The structures are based on modeling the superstructure (network, routings, flowsheet, etc.) with units, operations, ports and states (UOPSS) and the semantics (extent, magnitude, capacity, concentration, etc.) are based on quantity, logic and quality phenomenological (QLQP) variables for flows, holdups, yields, startups, setups, switchovers, shutdowns, densities, components, properties and conditions. Most community- and commercial-based MILP and NLP solvers are connected to IMPL to solve design, planning, scheduling, operations and process coordinating optimization problems as well as data reconciliation and parameter estimation problems with diagnostics of observability, redundancy and variability. Examples detailed in the chapter include industrial applications of poultry production planning with batch-lines, lubes sequence-dependent grade changeover sequencing and gasoline blend scheduling optimization with a user-directed heuristic to solve MINLP problems as MILP logistics with nominal quality cuts to approximate the nonlinearities from the blending. To summarize, IMPL may be considered as a confluence with the scientific disciplines of applied engineering, management and operations, computer science, information and communication technologies, statistics and now data science where optimization is known as decision science i.e., the science of decision-making.
PL-X IBM internal systems programming language (Programming Language/Cross Systems). There has been a progression from the original PL/S to the current PL/X. The language looks like and was originally based on PL/1 but it has picked up modern features along the way as well as features specifically for writing system software. AFAIK code exists written in all of the PL/* dialects and that the current PL/X compiler can handle all of them. Mark knows a lot better and may feel like commenting.
IBEX IBEX is a language that extends BINDEX with two new primitive datatypes (booleans and symbols) and some constructs controlled by booleans.
Simple Stackless Lisp I wrote a simple stackless lisp
iikuse I find constructed languages like Lojban and Ithkuil terribly interesting, but they are a bit too complex for me to actually pick up. So, being a programmer and a fan of FORTH, I decided to make a toy constructed language combining postfix notation and predicate logic.
OMAR Hypercosm produced a specialized programming language called OMAR (Object Modelling And Rendering) suitable for describing 3-D content. Hypercosm made available a web browser plugin for displaying this 3-D content. Unlike many other plugins, the Hypercosm plugin was available for Windows, MacOS, and Linux systems.
Altibase Hybrid relational and in-memory database management system
hurl Hurl is a command line tool that runs HTTP requests defined in a simple plain text format. It can perform requests, capture values and evaluate queries on headers and body response. Hurl is very versatile: it can be used for both fetching data and testing HTTP sessions
Hspec Hspec is a testing framework for Haskell.
hoot-smalltalk Hoot is a variation of Smalltalk that integrates the best features of Smalltalk with those of a host language and its virtual machine VM. The initial target platforms include Java (and its JVM), and C# (and its CLR). Hoot is an experimental new programming language which builds on experience and understanding gained during the development of Bistro Smalltalk. Thus, Hoot Smalltalk is the natural and conceptual successor of Bistro Smalltalk.
hoon Hoon is a high-level, statically typed, functional programming language, custom-designed for use with Urbit. For a functional language it has a surprisingly imperative style, and mastering it doesn't require knowing any advanced mathematics.
holyc HolyC is a variation of C developed by Terry A. Davis. HolyC is the official programming language for The Temple Operating System (TempleOS).
HMMM Hmmm (Harvey Mudd Miniature Machine) is a 16-bit, 23-instruction simulated assembly language with 28=256 16-bit words of memory.
Hjson Hjson is a syntax extension to JSON. It's NOT a proposal to replace JSON or to incorporate it into the JSON spec itself. It's intended to be used like a user interface for humans, to read and edit before passing the JSON data to the machine.
hilvl Hilvl is a programming language that is versatile but with a very small syntax. All code in hilvl are single-argument invocations of actions that belong to services. Services are the fundamental building blocks of a hilvl program. And the name hilvl reflects how this is a higher level of abstraction than objects and functions.
helium Helium is a functional programming language (a subset of Haskell) and a compiler designed especially for teaching.
Hedy Hedy is a gradual programming language to teach children programming. Gradual languages use different language levels, where each level adds new concepts and syntactic complexity. At the end of the Hedy level sequence, kids master a subset of syntactically valid Python.
hazel Hazel is a live functional programming environment rooted in the principles of type theory.
HXML Haxe compiler arguments can be stored in a .hxml file and can be executed with haxe . In hxml it is possible to use newlines and comments which makes it easier to maintain Haxe build configurations. It is possible to supply more arguments after the hxml file, e.g. haxe build.hxml -debug.
Literate Haskell Haskell is one of the few languages that provides native features to support literate programming. In haskell, a literate program is one with the suffix .lhs rather than .hs. In a literate Haskell program, there are two ways to distinguish between code and non-code portions. You can either prepend all code with a > , (bird style) or surround lines of code with \begin{code} and \end{code} pairs (latex style). For those who know, use and love latex, the latter is the suggested way to go.
Hare Hare is a systems programming language designed to be simple, stable, and robust. Hare uses a static type system, manual memory management, and a minimal runtime. It is well-suited to writing operating systems, system tools, compilers, networking software, and other low-level, high performance tasks.
hamler Hamler is a strongly-typed language with compile-time typechecking and built-in support for concurrency and distribution.
hakaru Hakaru is a simply-typed probabilistic programming language, designed for easy specification of probabilistic models and inference algorithms. This type of language is useful for the development of machine learning algorithms and stochastic modeling.
Hackett Hackett is an attempt to implement a Haskell-like language with support for Racket’s macro system, built using the techniques described in the paper Type Systems as Macros.
hackppl HackPPL is a probabilistic programming language (PPL) built within the Hack programming language
Kit HTML template language from CodeKit
HScript HScript is Houdini’s legacy scripting language.
High-Level Virtual Machine HLVM is a cross-platform open-source high-level virtual machine. The virtual machine is written in OCaml and uses the excellent LLVM library for efficient high-performance native code generation.
Header Dictionary Triples HDT compresses big RDF datasets while maintaining search operations
HCL HCL (HashiCorp Configuration Language) is a configuration language built by HashiCorp. The goal of HCL is to build a structured configuration language that is both human and machine friendly for use with command-line tools, but specifically targeted towards DevOps tools, servers, etc. HCL is also fully JSON compatible. That is, JSON can be used as completely valid input to a system expecting HCL. This helps makes systems interoperable with other systems. HCL is heavily inspired by libucl, nginx configuration, and others similar.
HAL Format HAL is a graph-based structure to efficiently store and index multiple genome alignments and ancestral reconstructions. HAL files are represented in HDF5 format, an open standard for storing and indexing large, compressed scientific data sets. Genomes within HAL are organized according to the phylogenetic tree that relate them: each genome is segmented into pairwise DNA alignment blocks with respect to its parent and children (if present) in the tree. Note that if the phylogeny is unknown, a star tree can be used. The modularity provided by this tree-based decomposition allows for efficient querying of sub-alignments, as well as the ability to add, remove and update genomes within the alignment with only local modifications to the structure. Another important feature of HAL is reference independence: alignments in this format can be queried with respect to the coordinates of any genome they contain.
gura Gura is an iterator-oriented programming language that focuses on iterators with improved functions for calculation and data processing. It makes you be able to write an artificial code for what used to need a lot of codes of repeat syntax.
Guile Guile is designed to help programmers create flexible applications that can be extended by users or other programmers with plug-ins, modules, or scripts. Guile is an implementation of the Scheme programming language, supporting the Revised5 and most of the Revised6 language reports, as well as many SRFIs. It also comes with a library of modules that offer additional features, like an HTTP server and client, XML parsing, and object-oriented programming.
groff Groff (GNU troff) is a typesetting system that reads plain text mixed with formatting commands and produces formatted output. Output may be PostScript or PDF, html, or ASCII/UTF8 for display at the terminal. Formatting commands may be either low-level typesetting requests (“primitives”) or macros from a supplied set. Users may also write their own macros. All three may be combined.
GraphIt GraphIt is a new DSL for graph computations that generates fast implementations for algorithms with different performance characteristics running on graphs with different sizes and structures. GraphIt separates what is computed (algorithm) from how it is computed (schedule). Programmers specify the algorithm using an algorithm language, and performance optimizations are specified using a separate scheduling language. The scheduling language enables programmers to easily search through this complicated tradeoff space by composing together a large set of edge traversal and vertex data layout optimizations.
Neo4j Graph database management system
Grammar Grammar is a Tree Language for creating new Tree Languages. By creating a grammar file you get a parser, a type checker, syntax highlighting, autocomplete, a compiler, and interpreter for executing your new language. Grammar uses both postfix and prefix language features.
goose Goose is a programming language in development that aims at being (yet another) c++ alternative.
Google Sheets Google Sheets supports cell formulas typically found in most desktop spreadsheet packages. These functions can be used to create formulas that manipulate data and calculate strings and numbers. You can change the language of Google Sheets functions between English and 21 other languages.
gogs-editor Gogs is a painless self-hosted Git service
Glyph Glyph2 is the scripting language for Pointwise. It is an extension to the tcl programming language that allows access to the commands and entities of the Pointwise application.
gleam Gleam is a statically typed functional programming language for building scalable concurrent systems. It compiles to Erlang and has straightforward interop with other BEAM languages such as Erlang, Elixir and LFE.
Giotto Giotto provides a programming abstraction for hard real-time applications that exhibit time-periodic and multimodal behavior, as in automotive, aerospace, and manufacturing control.
Genero Business Development Language Genero Business Development Language (BDL) is a program language designed to write an interactive database application.
Generic Expression Language Generic Expression Language (Gel) is a rich generic syntax that embodies many of the common syntactic conventions for operators, grouping and lists in widely-used languages. Prefix/infix operators are disambiguated by white-space, so that documents which violate common white-space conventions will not necessarily parse correctly with Gel. With some character replacements and adjusting for mismatch in operator precedence, Gel can extract meaningful structure from typical files in many languages, including Java, CSS, Smalltalk, and ANTLR grammars. This evaluation shows the expressive power of Gel, not that Gel can be used as a parser for existing languages. Gel is intended to serve as a generic language for creating composable domainspecific languages.
Galileo Galileo is a conceptual language for database applications in which the persistence of values is an orthogonal property, i.e., values of any type are persistent as long as they are accessible from the top level environment.
General purpose GP is a programming language in development that will enable more advanced programming with a Scratch-like design. GP stands for "Extensible Portable General purpose Block Language for Casual Programmers".
Recfiles GNU recutils is a set of tools and libraries to access human-editable, text-based databases called recfiles. The data is stored as a sequence of records, each record containing an arbitrary number of named fields. Advanced capabilities usually found in other data storage systems are supported: data types, data integrity (keys, mandatory fields, etc.) as well as the ability of records to refer to other records (sort of foreign keys). Despite its simplicity, recfiles can be used to store medium-sized databases.
Autoconf GNU Autoconf is a tool for producing configure scripts for building, installing, and packaging software on computer systems where a Bourne shell is available.
GDScript GDScript is a high level, dynamically typed programming language used to create content. It uses a syntax similar to Python (blocks are indent-based and many keywords are similar). Its goal is to be optimized for and tightly integrated with Godot Engine, allowing great flexibility for content creation and integration.
GCC GIMPLE GCC is a widely used compiler infrastructure that supports a variety of input languages, e.g., C, C++, Fortran, Java, and Ada, and over 30 different target machine architectures. GCC translates each of its front-end languages into a language-independent intermediate representation, called GIMPLE, which then gets translated to machine code for one of GCC’s many target architectures. A subset of GENERIC.
Fuzuli Fuzuli has a syntax similar to Lisp but it is not intended to be an other Lisp clone. It has got several properties inhereted from Algol family and others. For example; syntax of while and foreach statements were directly derived from C++ and R, respectively. Some string manipulation functions share the same names and definitions from Visual Basic. Math and IO libraries are like C++ standard library and MySql library uses libmysql directly.
fmj Full Metal Jacket is very different from other programming languages. It's intrinsically parallel, with no flow of control, and has no variables. Programs are composed almost entirely with the mouse rather than keyboard, and type inference and other checks take place while you edit your program. There are a few other visual dataflow languages out there, but Full Metal Jacket is simpler than them, and has a cleaner design. Full Metal Jacket is general-purpose, though it might in due course find a niche. Some adjustment will be needed by programmers who are most comfortable with imperative programming languages, such as Java or C. To master dataflow, they will have to change they way they think. They should regard this as a worthwhile challenge which will make them better programmers. Functional programmers might have a slightly easier time.
tea From the creator of brew, tea is a standalone, binary download for all platforms that puts the entire open source ecosystem at your fingertips. Casually and effortlessly use the latest and greatest or the oldest and most mature from any layer of any stack. Break down the silos between programming communities, throw together scripts that use entirely separate tools and languages and share them with the world with a simple one-liner.All you need is tea.
Frenetic Frenetic: a network programming language
concept-script Frege initiated an ambitious program to use a precise notation which would help in the rigorous development of mathematics. Although his efforts were almost entirely focused on the natural numbers, he discussed possible applications to geometry, analysis, mechanics, physics of motion, and philosophy. The precise notation of Frege was introduced in Concept Script (Begriffschrift) in 1879. This was a two-dimensional notation whose powers he compared to a microscope. The framework in which he set up his Concept Script was quite simple -- we live in a world of objects and concepts, and we deal with statements about these in a manner subject to the laws of logic. Thus Frege had only one model in mind, the real world. Let us refer to this as the absolute universe. From this he was going to distill the numbers and their properties. The absolute universe approach to mathematics via logic was dominant until 1930 -- we see it in the work of Whitehead and Russell (1910-1913). His formal system with two-dimensional notation had the universal quantifier, negation, implication, predicates of several variables, axioms for logic, and rules of inference. The explicit universal quantifier, predicates of several variables and the rules of inference were new to formal systems!
Formula language Formula language is a simple, easy-to-use programming language that can be found in many Lotus products -- such as Lotus 1-2-3 and Lotus Notes. Formula language has been integrated into Lotus Notes since its inception in 1989 and has included numerous enhancements over the years.
SYMBAL Formula Manipulation Language
Flowgorithm Flowgorithm is a free beginner's programming language that is based on simple graphical flowcharts.
Flatline Flatline is a lispy language for the specification of values to be extracted or generated from an input dataset, using a finite sliding window of input rows.
Flare Flare is a proposal for the first "annotative" programming language. In dialects of LISP, both the program and the program data are represented as lists. In Flare, the program, program data, and ideally the program state, are all represented as well-formed XML. Because XML is annotative (additional sub-elements can be easily added to any parent element without destroying the structural integrity of existing data) and extensible (new sub-element types can be easily created), these properties are shared by Flare objects and Flare programs. This fundamental idiom enables a wide variety of new patterns, and should enable significantly greater modularity, cleanness, ease of adaptation, and so on.
Edina First look at Edina, a simple Forth-like compiled language
Gaiman First 1.0.0 beta version of Gaiman programming language
Finite State Language Finite State Language, or FSL (pronounced "fossil,") is a programming language to make complex Finite State Machines easy to create and maintain. Finite State Machines can help make your code simpler, easier to test, more provable, and easier to reason about.
Filebench WML Filebench is a file system and storage benchmark that can generate a large variety of workloads. Unlike typical benchmarks it is extremely flexible and allows to specify application's I/O behavior using its extensive Workload Model Language (WML).
Fibonacci Fibonacci is an object-oriented database programming language characterized by static and strong typing, and by new mechanisms for modeling databases in terms of objects with roles, classes, and associations.
Fawlty Fawlty Language is an IDL8 (Interactive Data Language) compatible compiler. Fawlty Language is a closed source, but freely usable IDL clone for Linux, Windows and Mac OS X.
Farcaster Farcaster is a decentralized social network built on top of Ethereum. The Layer 1 blockchain manages user identities, while a Layer 2 network propagates updates between users. It offers: Secure, memorable, and human-readable user identifiers like @alice. Real-time settlement and propagation of changes between users. Decentralized access to all data on the network at reasonable costs.
Fable Fable is a compiler that brings F# into the JavaScript ecosystem
FaCT FaCT is a domain-specific language that aids you in writing constant-time code for cryptographic routines that need to be free from timing side channels. This is the compiler for the Flexible and Constant Time cryptographic programming language. Real-world cryptographic code is often written in a subset of C intended to execute in constant-time, thereby avoiding timing side channel vulnerabilities. This C subset eschews structured programming as we know it: if-statements, looping constructs, and procedural abstractions can leak timing information when handling sensitive data. The resulting obfuscation has led to subtle bugs, even in widely-used high-profile libraries like OpenSSL. To address the challenge of writing constant-time cryptographic code, we present FaCT, a crypto DSL that provides high-level but safe language constructs. The FaCT compiler uses a secrecy type system to automatically transform potentially timing-sensitive high-level code into low-level, constant-time LLVM bitcode. We develop the language and type system, formalize the constant-time transformation, and present an empirical evaluation that uses FaCT to implement core crypto routines from several open-source projects including OpenSSL, libsodium, and curve25519-donna. Our evaluation shows that FaCT's design makes it possible to write \emph{readable}, high-level cryptographic code, with \emph{efficient}, \emph{constant-time} behavior.
Fast Healthcare Interoperability Resources FHIR builds on previous data format standards from HL7, like HL7 version 2.x and HL7 version 3.x. But it is easier to implement because it uses a modern web-based suite of API technology, including a HTTP-based RESTful protocol, HTML and Cascading Style Sheets for user interface integration, a choice of JSON, XML or RDF for data representation, and Atom for results.
Friendly Enough Expression Language FEEL defines a syntax for expressing conditions that input data should be evaluated against
Fully Automated Compiling Technique FACT is an early discontinued computer programming language, created by the Datamatic Division of Minneapolis Honeywell for its model 800 series business computers in 1959. FACT was an acronym for "Fully Automated Compiling Technique". It was an influence on the design of the COBOL programming language.
F* F* is a dependently typed programming language and proof assistant. In practice, rather than a single language, the F* ecosystem is also a collection of domain-specific languages (DSLs). A common use of F* is to embed within it programming languages at different levels of abstraction or for specific programming tasks, and for the embedded language to be engineered with domain-specific reasoning, proof automation, and compilation backends.
F Prime F' - A flight software and embedded systems framework
plink-bim-format Extended variant information file accompanying a .bed binary genotype table.
Extempore Extempore is a programming language and runtime environment designed to support cyberphysical programming, where a human programmer operates as an active agent in the world.
Gherkin Executable specifications
FlowNet Ethernet alternative. Like ATM, FlowNet is a switched network based on fixed-size cells. Unlike ATM, FlowNet cells are large--800 bytes instead of 53. This allows room for a 14-byte Ethernet header plus an additional QoS extension. The QoS extension header is 18 bytes, making the full FlowNet header 32 bytes long. The remaining 768 bytes (=256+512) are data payload. FlowNet interoperates with Ethernet through a simple bridge device.
Entropy Entropy is a language where data decays the more it's used.
Enso Enso is an award-winning interactive programming language with dual visual and textual representations.
xTAO Modeling Language Enabling a declarative approach to the specification of multi-agent systems
emfatic Emfatic is a language designed to represent EMF Ecore models in a textual form.
emerald-lang Emerald is an object oriented language that uses prototypal based inheritance.
Embedded Crystal Embedded Crystal (ECR) is a template language for embedding Crystal code into other text, that includes but is not limited to HTML. The template is read and transformed at compile time and then embedded into the binary.
Elvish Elvish is an expressive programming language and a versatile interactive shell, combined into one seamless package. It runs on Linux, BSDs, macOS and Windows.
Election Markup Language Election Markup Language (EML) is an XML-based standard to support end to end management of election processes.
Đ Edh is a dynamically & strongly typed, procedural (thus imperative), value-oriented (i.e. immutable first, yet with non-traditional Object constructs), interpreted programming language, that parasitic on GHC and heavily relying on the Haskell implementation of Software Transactional Memory for unified intuition of concurrency and data-consistency.
edgeql EdgeQL is the primary language of EdgeDB. It is used to define, mutate, and query data.
eco-editor Eco is a prototype editor for editing composed languages. It is not feature complete, it is not intended for production, and it does have bugs. Eco is distributed under a BSD/MIT license.
Easybuild EasyBuild is a software build and installation framework that allows you to manage (scientific) software on High Performance Computing (HPC) systems in an efficient way.
Magic Paper Early interactive symbolic math system.
orca-pl Each letter of the alphabet is an operation, lowercase letters typically operate on bang(*), uppercase letters operate on each frame. Bangs can be generated by various operations, such as E colliding with a 0, see the bang.orca example. Watch a music video of ORCΛ in action. C Port for the ORCΛ programming environment, with a commandline interpreter.
epsilon EOL is an imperative programming language for creating, querying and modifying EMF models. You can think of it as a mixture of Javascript and OCL, combining the best of both worlds. As such, it provides all the usual imperative features found in Javascript (e.g. statement sequencing, variables, for and while loops, if branches etc.) and all the nice features of OCL such as those handy collection querying functions.
ICETRAN ENGINEERING PROGRAMS FOR ICES ARE WRITTEN IN ICETRAN AND ARE PROCESSED BY THE ICETRAN PRECOMPILER, WHICH GENERATES AN EQUIVALENT FORTRAN PROGRAM
ELFE ELFE is a very simple and small programming language specifcally designed for everyday programming, notably for the Internet of Things.
EEX EEx stands for Embedded Elixir. It allows you to embed Elixir code inside a string in a robust way.
ebg EBG is a lazy, higher order functional programming language with a Hindley-Milner type system, modules, separate compilation, algebraic types, pattern matching, and an interface to Java based on the ob ject-oriented model of program execution.
E E is an object-oriented programming language for secure distributed computing.
mmix During the 1990s I spent considerable time designing a computer that would be representative of modern machines, yet easy to learn. Several of the leading experts in the field gave me considerable help with the design. The result was MMIX — "A RISC computer for the new millennium". In 1999 I completed the preliminary software to support basic MMIX programming and the simulation of many versions of the architecture.
MarkLogic Document-oriented database management system
Memcached Distributed memory caching system, used as a database
Apache Phoenix Distributed SQL query engine for Apache HBase
YugabyteDB Distributed SQL database management system
TiDB Distributed SQL database management system
FRAN Dialect of Haskell for interactive programming of animation.
GraphQL+- Dgraph’s GraphQL+- is based on Facebook’s GraphQL. GraphQL wasn’t developed for Graph databases, but its graph-like query syntax, schema validation and subgraph shaped response make it a great language choice. We’ve modified the language to better support graph operations, adding and removing features to get the best fit for graph databases. We’re calling this simplified, feature rich language, “GraphQL+-”.
dexvis Dex : The Data Explorer -- A data visualization tool written in Java/Groovy/JavaFX capable of powerful ETL and publishing web visualizations.
Decision Model & Notation Decision Model and Notation (DMN) is an industry standard for modeling and executing decisions that are determined by business rules.
Datomic Datomic's query and rules system is an extended form of Datalog. Datalog is a deductive query system, typically consisting of: A database of facts; A set of rules for deriving new facts from existing facts; a query processor that, given some partial specification of a fact or rule: finds all matching facts.
o2 Database programming language.
DataWeave DataWeave is the MuleSoft expression language for accessing and transforming data received through a Mule app. DataWeave is tightly integrated with Mule runtime, which runs the scripts and expressions in your Mule app.
DAX Data Analysis Expressions (DAX) is a formula expression language used in Analysis Services, Power BI, and Power Pivot in Excel. DAX formulas include functions, operators, and values to perform advanced calculations and queries on data in related tables and columns in tabular data models.
Dashrep Dashrep™, the text-manipulation programming language that is powerful and fast, yet simple
Darcs Advanced Revision Control System Darcs is a distributed version control system created by David Roundy.
dalvik-bytecode Dalvik bytecode format is still used as a distribution format, but no longer at runtime in newer Android versions
Dak Dak is a Lisp like language that transpiles to JavaScript.
DTrace DTrace is a comprehensive dynamic tracing framework created by Sun Microsystems for troubleshooting kernel and application problems on production systems in real time.
dslx DSLX is a domain specific, functional language to build hardware that can also run effectively as host software. The DSL targets the XLS compiler (by conversion to XLS IR) to enable flows for FPGAs and ASICs (note that other frontends will become available in the future). DSLX mimics Rust, while being an immutable expression-based dataflow DSL with hardware-oriented features; e.g. arbitrary bitwidths, entirely fixed size objects, fully analyzeable call graph, etc. To avoid arbitrary new syntax/semantics choices the DSL mimics Rust where it is reasonably possible; for example, integer conversions all follow the same semantics as Rust.
DM DM is a programming language for the creation of multi-user worlds. By `world' I mean a virtual multi-media environment where people assume personae through which they interact with one another and computer-controlled objects. This could take the form of a competitive game, a role-playing adventure, a discussion board, or something we haven't even imagined.
Differential Datalog DDlog is a programming language for incremental computation. It is well suited for writing programs that continuously update their output in response to input changes. A DDlog programmer does not write incremental algorithms; instead they specify the desired input-output mapping in a declarative manner.
DDF DDF is a data model for collaborative harmonization of multidimensional statistics.
D2 D2 is a domain-specific language (DSL) that stands for Declarative Diagramming. Declarative, as in, you write in text what you want diagrammed, we generate it.
C flat C♭: a low-level subset of C. Journal of C Language Translation, 3(3):214–226, December 1991.
C∀ C∀ (C-for-all) is an open-source project extending ISO C with modern safety and productivity features, while still ensuring backwards compatibility with C and its programmers. C∀ is designed to have an orthogonal feature-set based closely on the C programming paradigm (non-object-oriented) and these features can be added incrementally to an existing C code-base allowing programmers to learn C∀ on an as-needed basis. In many ways, C∀ is to C as Scala is to Java, providing a research vehicle for new typing and control-flow capabilities on top of a highly popular programming language allowing immediate dissemination.
Petr Czech visual language for kids, created in 1999, written by developer who was cheated by author of Baltik and Baltazar.
baltazar Czech visual educational language, for MS-DOS only, created by author of Baltík
Cypher Query Language Cypher is a declarative, SQL-inspired language for describing patterns in graphs visually using an ascii-art syntax. It allows us to state what we want to select, insert, update or delete from our graph data without requiring us to describe exactly how to do it. A language with neo4j.
Cyber Cyber is a new language for fast, efficient, and concurrent scripting.
curv Curv is a programming language for creating art using mathematics. It’s a 2D and 3D geometric modelling tool that supports full colour, animation and 3D printing.
ctalk Ctalk is a compact object oriented language that works closely with C. That means you can use Ctalk for GUI, network, client-server, and systems programs as well as traditional object oriented simulations.
crush Crush is an attempt to make a traditional command line shell that is also a modern programming language. It has the features one would expect from a modern programming language like a type system, closures and lexical scoping, but with a syntax geared toward both batch and interactive shell usage.
Croc Croc is a small, dynamically-typed language most closely related to Lua, with C-style syntax. Its semantics are borrowed mainly from Lua, D, Squirrel, and Io, though many other languages served as inspirations.
Creole Creole is a lightweight markup language, aimed at being a common markup language for wikis, enabling and simplifying the transfer of content between different wiki engines.
Crema Crema is a LLVM front-end that aims to specifically execute in sub-Turing Complete space. Designed to be simple to learn, and practical for the majority of programming tasks needed, Crema can restrict the computational complexity of the program to the minimum needed to improve security.
Cosmos Cosmos 0.2 - now with Pure Arithmetics
CorelScript CorelSCRIPT is a dialect of Basic that serves as the macro extension language for many products from Corel Corp, including their line of graphics products. While the syntax of CorelSCRIPT is nearly identical to that of Microsoft's Visual Basic, it is distinguished by the large number of built-in functions that it provides for the end-user. In versions of CorelDraw 6.0 and later, for example, essentially every function the drawing tool can perform is available to the CorelSCRIPT programmer. Also, Corel tools can compile scripts to speed execution; this capability is somewhat unusual for an application macro language. Like the Visual Basic language systems it resembles, CorelSCRIPT is compatible with MS-Windows OLE automation facility, allowing a CorelSCRIPT program to invoke and control any OLE-capable Windows application. CorelSCRIPT is a commercial product available only with Corel Corporation products. Meager information about the language is available on the WWW.
Copilot Copilot is a realtime programming language and Runtime Verification framework. It allows users to write concise programs in a simple but powerful way using a stream-based approach. Programs can be interpreted for testing, or translated C99 code to be incorporated in a project, or as a standalone application. The C99 backend ensures us that the output is constant in memory and time, making it suitable for systems with hard realtime requirements.
Dendral Considered the first expert system because it automated the decision-making process and problem-solving behavior of organic chemists
Concise Encoding Concise Encoding gives you ease and efficiency with its 1:1 compatible text and binary formats.
CBOR data definition language Concise Data Definition Language (CDDL): A Notational Convention to Express Concise Binary Object Representation (CBOR) and JSON Data Structures
cosh Concatenative command-line shell
Conan Conan, the C / C++ Package Manager for Developers
SMT Common input and output languages for SMT solvers.
Combined Log Format Common Log Format plus referrer and user agent columns.
docopt Command-line interface description language
MariaDB ColumnStore Column-oriented database management system
CodeQL CodeQL let's you query code as if it were data.
Coco/R Coco/R is a compiler generator, which takes an attributed grammar of a source language and generates a scanner and a parser for this language. The scanner works as a deterministic finite automaton. The parser uses recursive descent. LL(1) conflicts can be resolved by a multi-symbol lookahead or by semantic checks. Thus the class of accepted grammars is LL(k) for an arbitrary k.
Firebase Realtime Database Cloud-hosted real-time document-oriented database
CIR Clang IR (CIR) is a new IR for Clang.
Cish Cish
Cirru Cirru Project helps people code in syntax tree. It offers a tree editor and a text syntax.
Ciel Ciel is a lisp-like language implemented in C++. What Clojure is to Java, Ciel is designed to be to C++.
chocolatey-pm Chocolatey is a package manager for Windows (like apt-get or yum but for Windows).
chirp Chirp is a Scratch modification made by Jens, who was at the time a member of the Scratch Team. It was the precursor to BYOB and adds a number of new features to Scratch, while remaining fully compatible
chef Chef is a programming language in which programs look like recipes.
Cell Cell is a very high-level embeddable language. Cell's data model combines a staple of functional programming, algebraic data types, with relations and other ideas from relational databases.
cat Cat is a higher-order stack-oriented language.
Datalisp Canonical S-expressions and logic programming for metaprogramming.
Candy Codes CandyCodes: simple universally unique edible identifiers for confirming the authenticity of pharmaceuticals. A 3-D UID format.
rds-format Can also be an ASCII data format.
Cali-Lang Cali is an object oriented interpreted programming language written in Java. It is an efficiency (glue) language that is loosely typed. Cali has it's own standard library but anyone can create external Java modules to extend Cali. In fact, the entire standard library was written by wrapping Java code.
Calc4 Calc4 is a programming language where everything in its code is an operator.
Caché Basic Caché is a high-performance object database with several built-in general-purpose programming languages. It supports multiple processes and provides concurrency control. Each process has direct, efficient access to the data.
CRAM file format CRAM files typically vary from 30 to 60% smaller than BAM, depending on the data held within them.
CORAL CORAL (Computer On-line Real-time Applications Language) is a programming language originally developed in 1964 at the Royal Radar Establishment (RRE), Malvern, UK, as a subset of JOVIAL
CMIX CMIX is a computer music "language" designed to create and manipulate soundfiles, or files containing raw binary data which can be converted into sound on a computer equipped with an appropriate digital-to-analog convertor. It is somewhat similar to CSOUND and CMUSIC (two other popular software synthesis and signal-processing computer music packages). All three of these languages are in one way or another derived from the work done by Max Matthews and others at Bell Laboratories in the late 1950's and 1960's.
CLiX markup CLiX is a constraint language based on first order logic. It was first specified in 1998, when XML was not yet ubiquitous, in research at University College London. The language has since been developed and taken forward by Systemwire Ltd., a spin-off company that provides rule-based validation products around CLiX. Even though a commercial implementation is available, the language specification is published, and free for anybody to implement. It is hosted at http://www.clixml.org.
Clausal Language CL (Clausal Language) is a declarative programming language with the look and feel of a modern functional programming language. CL identifies the domain of symbolic expressions of LISP with the domain of natural numbers.
cimfast CIMfast was an event driven language for "computer integrated manufacturing", developed in the early 1990's. It was high level language used to control BaseStar. BaseStar was a software library for manufacturing support (basically it was messaging middleware, nothing specific for any kind of industry), developed and sold by DEC. It had C API. CIMfast was language intended to replace the need for low level C. CIMfast controlled manufacturing line was deployed by Fiat.
Cheri CHERI extends conventional hardware Instruction-Set Architectures (ISAs) with new architectural features to enable fine-grained memory protection and highly scalable software compartmentalization.
CCS CCS is a proprietary scripting language for executing sequences of command-line interface (CLI) commands on NetMRI-supported network devices, to perform job automation tasks. If you know Cisco IOS, writing CCS scripts is relatively straightforward.
C3 C3 is a programming language that builds on the syntax and semantics of the C language, with the goal of evolving it while still retaining familiarity for C programmers.
c-talk C-Talk is interpreted scripting language with C-like syntax and dynamic type checking. Variables in C-Talk have no type. So there is no compile time type checking in C-Talk, all checking is performed at runtime. To preserve reference integrity, explicit memory deallocation is prohibited in C-Talk, unused objects are automatically deallocated by garbage collector.
c-smile C-SMILE is a scripting language, which inherits it's syntax and structure from C, C++, Java(tm) and JavaScript. On hypothetical "axis of programming languages" it resides somewhere between Java(tm) and JavaScript. In the same way as in JavaScript, all variables are typeless and as in Java it is mandatory to declare variables before usage. C-SMILE has a compiler, a virtual machine running bytecodes, and a C/C++ extensible runtime. C-SMILE is intended to run in standalone or embedded mode.
business-rule-language Business Rule Language (BRL) allows IF/THEN testing on certain information available when the rules execute. Your own cancel message can be included within the rules you create by using special message variables. BRL is a non-procedural, high-level application development language that allows you to develop sophisticated programs with less effort than conventional programming languages. BRL rules consist of three parts: the rule name, which serves as a comment or description, and is not syntactically necessary to the rule; a supporting condition (antecedent) or procedure statement; and a conclusion.
Bun Bundle, transpile, install and run JavaScript & TypeScript projects — all in Bun. Bun is a new JavaScript runtime with a native bundler, transpiler, task runner and npm client built-in.
Bucardo Bucardo is an asynchronous PostgreSQL replication system, allowing for multi-source, multi-target operations. Bucardo is a replication system for Postgres that supports any number of sources and targets (aka masters and slaves). It is asynchronous and trigger based.
Bro Bro's domain-specific scripting language enables site-specific monitoring policies.
BrightScript BrightScript is a powerful scripting language for building media and networked applications for embedded devices. This language features integrated support for a lightweight library of BrightScript objects, which are used to expose the API of the platform (device) that is running BrightScript. The BrightScript language connects generalized script functionality with underlying components for networking, media playback, UI screens, and interactive interfaces; BrightScript is optimized for generating user-friendly applications with minimal programmer effort. Now part of Roku.
New AWK Brian Kernighan's nawk (New AWK) source was first released in 1993 unpublicized, and publicly since the late 1990s; many BSD systems use it to avoid the GPL license.
Bounce Bounce is a real time visual data flow programming language, designed to create interactive graphical simulations, and to filter and control midi, serial, ethernet, and other devices.
Boron Boron is a scripting language similar to REBOL. The interpreter is a C library which may be copied under the terms of the LGPLv3.
Bon Bon was a programming language created by Ken Thompson while he worked on the MULTICS operating system. Bon was named either after Thompson's wife Bonnie or else, after "a religion whose rituals involve the murmuring of magic formulas" (a reference to the Tibetan native religion Bön).
Bolin Bolin - A compiler friends and I wrote
Blueprints Blueprints is the visual scripting system inside Unreal Engine 4 and is a fast way to start prototyping your game.
Blade Blade Programming Language v0.0.73
Bistro Bistro is a variation of Smalltalk that integrates the best features of Smalltalk and Java. Bistro Smalltalk is an experimental programming language that runs on the Java Virtual Machine, or JVM.
BMD Biomedical Computer Programs for Data Description and Statistical Analyses
Binary Lambda Calculus Binary lambda calculus (BLC) is a minimal, pure functional programming language invented by John Tromp in 2004,[1] based on a binary encoding of the untyped lambda calculus in De Bruijn index notation.
Binary Ninja Binary Ninja is an interactive disassembler, decompiler, and binary analysis platform for reverse engineers, malware analysts, vulnerability researchers, and software developers that runs on Windows, macOS, Linux.
Biferno Biferno is a new generation object-oriented Web scripting language that allows developers the rapid implementation of dynamic Web applications and of sites that offer a high degree of user interactivity.
Bicep Bicep is a Domain Specific Language (DSL) for deploying Azure resources declaratively.
Literate CoffeeScript Besides being used as an ordinary programming language, CoffeeScript may also be written in “literate” mode. If you name your file with a .litcoffee extension, you can write it as a Markdown document — a document that also happens to be executable CoffeeScript code. The compiler will treat any indented blocks (Markdown’s way of indicating source code) as executable code, and ignore the rest as comments. Code blocks must also be separated from comments by at least one blank line.
Berry Berry is a ultra-lightweight dynamically typed embedded scripting language. It is designed for lower-performance embedded devices. The Berry interpreter-core's code size is less than 40KiB and can run on less than 4KiB heap (on ARM Cortex M4 CPU, Thumb ISA and ARMCC compiler).
L6 Bell Telephone Laboratories' Low-Level Linked List Language L6 (pronounced “L-six”) is a new programming language for list structure manipulations. It contains many of the facilities which underlie such list processors as IPL, LISP, COMIT and SNOBOL, but permits the user to get much closer to machine code in order to write faster-running programs, to use storage more efficiently and to build a wider variety of linked data structures.
MathJax Beautiful and accessible math in all browsers
Bazel Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language. Bazel supports projects in multiple languages and builds outputs for multiple platforms. Bazel supports large codebases across multiple repositories, and large numbers of users. See starlark for the language.
Basis Codec Basis Universal GPU Texture and Texture Video Compression Reference Codec
AIR Bare Bones Backend / Assembly Intermediate Representation. The B3 compiler comprises two intermediate representations: a higher-level SSA-based representation called B3 IR and a lower-level representation that focuses of machine details, like registers. This lower-level form is called Air (Assembly Intermediate Representation).
bamboo Bamboo is a programming language for Ethereum contracts.
bscript-interpreter BScript is a (yet another) BASIC interpreter.
Browser Extensible Data Format BED (Browser Extensible Data) format provides a flexible way to define the data lines that are displayed in an annotation track. BED lines have three required fields and nine additional optional fields. The number of fields per line must be consistent throughout any single set of data in an annotation track. The order of the optional fields is binding: lower-numbered fields must always be populated if higher-numbered fields are used.
BBj BASIS created the newest version of BBx®, the sixth generation, using Java technology. Business BASIC on Java, registered as BBj®, gives application developers the necessary tools to create modern, 21st century e-commerce and enterprise solutions
BASIC BASIC (Beginner's All-purpose Symbolic Instruction Code)[1] is a family of general-purpose, high-level programming languages whose design philosophy emphasizes ease of use. In 1964, John G. Kemeny and Thomas E. Kurtz designed the original BASIC language at Dartmouth College. They wanted to enable students in fields other than science and mathematics to use computers. At the time, nearly all use of computers required writing custom software, which was something only scientists and mathematicians tended to learn.
BARE BARE is a simple binary representation for structured application data.
Binary Alignment Map BAM is the compressed binary representation of SAM (Sequence Alignment Map). BAM is in compressed BGZF format.
B3 IR B3 IR is a C-like SSA representation of a procedure. A procedure has a root block at which it starts execution when it is invoked. A procedure does not have to terminate, but if it does, then it can be either due to a Return, which gracefully returns some value, or by a side-exit at designated instructions. B3 gives the client a lot of flexibility to implement many different kinds of side-exits. B3 is designed to represent procedures for the purpose of transforming them. Knowing what transformations are legal requires knowing what a procedure does. A transformation is valid if it does not change the observable behavior of a procedure. This document tells you what B3 procedures do by telling you what each construct in B3 IR does.
ARM Templates Azure Resource Manager templates are JavaScript Object Notation (JSON) files that define the infrastructure and configuration for your project.
AviSynth Avisynth is a scripting language and a collection of filters for simple (and not so simple!) non-linear video editing tasks. It frameserves video to applications
Avail Avail is a multi-paradigmatic general purpose programming language whose feature set emphasizes support for articulate programming.
.dwg Autodesk estimates that in 1998 there were in excess of two billion DWG files in existence.
SubX Author of Mu decided this year to switch implementation from C++ to his own x86 assembler subset named SubX.
Austral Austral is a new systems programming language. You can think of it as Rust: The Good Parts or a modernized, stripped-down Ada. It features a strong static type system, linear types, capability-based security, and strong modularity.
Atomos Atomos is the first programming language with implicit transactions, strong atomicity, and a scalable multiprocessor implementation. Atomos is derived from Java, but replaces its synchronization and conditional waiting constructs with simpler transactional alternatives.
Atomese Atomese was originally intended to be a language for knowledge representation (KR): that is, a way of encoding facts and hypothesis, in a machine-readable way, such that the knowledge can be manipulated, data-mined, reasoned with. This language subset was vaguely inspired by Prolog and Datalog. More correctly, it was constructed by layering concepts from mathematical logic onto a graph database: representing logical, symbolic statements as graphs.
pliant At the beginning, Pliant is a computing language. It's target is: enable to keep better control on the computing system and better adaptation capabilities thanks to reduced complexity. This has been achieved mostly through enabling to develop everything in a single language that combines high expression power with execution efficiency.
telefile-assembly Assembly language for Teleregister Telefile.
AsciiMath AsciiMath is an easy-to-write markup language for mathematics.
Linux Kernel Module As of Linux kernel version 2.6, KO files are used in place of .O files and contain additional information that the kernel uses to load modules. The Linux program modpost can be used to convert O files into KO files.
AMTRAN As a programming language, AMTRAN is designed to satisfy two objectives: the reduction of programming cost and effort by at least an order of magnitude, and the provision of a semiautomatic numerical analytical problem solving system. It resembles a blend of FORTRAN and ALGOL but possesses certain additional features. These include the following.
Armed Bear Common Lisp Armed Bear Common Lisp (ABCL) is a full implementation of the Common Lisp language featuring both an interpreter and a compiler, running in the JVM. Originally started to be a scripting language for the J editor, it now supports JSR-223 (Java scripting API): it can be a scripting engine in any Java application. Additionally, it can be used to implement (parts of) the application using Java to Lisp integration APIs.
ArkScript ArkScript is a small, fast, functional and scripting language for video games.
Argon Argon - an interpreted multi-paradigm programming language
ArchieML ArchieML (or "AML") was created at The New York Times to make it easier to write and edit structured text on deadline that could be rendered in web pages, or more specifically, rendered in interactive graphics.
FLUX Application Architecture for Building User Interfaces
Apex Apex is a proprietary programming language provided by the Force.com platform to developers similar to Java and C#. It is a strongly typed, object-oriented, case-insensitive programming language, following a dot-notation and curly-brackets syntax. Apex can be used to execute programmed functions during most processes on the Force.com platform including custom buttons and links, event handlers on record insertion, update, or deletion, via scheduling, or via the custom controllers of Visualforce pages. Due to the multitenant nature of the platform, the language has strictly imposed governor limitations[61] to guard against any code monopolizing shared resources. Salesforce provides a series of asynchronous processing methods for Apex to allow developers to produce longer running and more complex Apex code.
Apache Maven Apache Maven is a software project management and comprehension tool. Based on the concept of a project object model (POM), Maven can manage a project's build, reporting and documentation from a central piece of information.
Apache Arrow Apache Arrow is a cross-language development platform for in-memory data. It specifies a standardized language-independent columnar memory format for flat and hierarchical data, organized for efficient analytic operations on modern hardware. It also provides computational libraries and zero-copy streaming messaging and interprocess communication. Languages currently supported include C, C++, Java, JavaScript, Python, and Ruby.
Ant Build System Apache Ant is a Java library and command-line tool whose mission is to drive processes described in build files as targets and extension points dependent upon each other. The main known usage of Ant is the build of Java applications. Ant supplies a number of built-in tasks allowing to compile, assemble, test and run Java applications. Ant can also be used effectively to build non Java applications, for instance C or C++ applications. More generally, Ant can be used to pilot any type of process which can be described in terms of targets and tasks.
prodel Another Japanese programming language
chappe-code An optical telegraph notation.
Mentat An object-oriented macro data flow system
PHOCUS An object-oriented Prolog-like language.
Lily An interpreted language with a focus on expressiveness and type safety
flame-ir An intermediate representation (IR) in static single assignment (SSA) form. This type of IR is favored by state-of-the-art optimizing compilers such as LLVM and GCC. Flame IR is designed from the ground up with the express intent of making it as suitable as possible for a wide range of optimizations and analyses. Flame is a collection of C# libraries for building tools that read, analyze, optimize and write managed languages.
Parse Tree Notation An important aspect of Parse Tree Notation (PTN) is that the data structure being manipulated is the parse tree for the program, not its token list. Pattern matching in PTN is on subtrees of the program's parse tree, using DCG rules to identify the subtrees of interest
Scroll An extensible alternative to Markdown built on Tree Notation.
kai An expressive low level programming language
System V ABI An example of a symbol table can be found in the SysV Application Binary Interface (ABI) specification, which mandates how symbols are to be laid out in a binary file, so that different compilers, linkers and loaders can all consistently find and work with the symbols in a compiled object.
semicolon An esoteric language made up of only semicolons. You can't escape the semicolon monster!
Gentoo Ebuild An ebuild file is a text file, used by Gentoo package managers, which identifies a specific software package and how the Gentoo package manager should handle it. It uses a bash-like syntax style and is standardized through the EAPI version. Gentoo Linux uses ebuilds as the package management format for individual software titles.
Bayer Expressions An alternative notation for S-Expressions that uses fewer parentheses. As described by the creator: Indentation implies parentheses. A pipe "|" opens a parenthesis that auto-closes at the end of that line or at the next ")". A dollar "$" opens a parenthesis that auto-closes when the indentation recovers. The result has a lighter, more poetic look than any language I know, and the parentheses that are left actually matter, so I pay attention to them.
OpenType Feature File An OpenType feature file is a text file that contains the typographic layout feature specifications for an OpenType font in an easy-to-read format. It may also contain override values for certain fields in the font tables. It is read in during the creation or editing of an OpenType font.
Molfile An MDL Molfile is a file format for holding information about the atoms, bonds, connectivity and coordinates of a molecule. The molfile consists of some header information, the Connection Table (CT) containing atom info, then bond connections and types, followed by sections for more complex information. The molfile is sufficiently common that most, if not all, cheminformatics software systems/applications are able to read the format, though not always to the same degree. It is also supported by some computational software such as Mathematica. The current de facto standard version is molfile V2000; although, more recently, the V3000 format has been circulating widely enough to present a potential compatibility issue for those applications that are not yet V3000-capable.
DETAB-X An Improved Business-Oriented Computer Language
Timeless Instruction Set (TL ISA) 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.
Edje Data Collection An Edje Data Collection, it's a plain text file (normally identified with the .edc extension), consisting of instructions for the Edje Compiler.
BQN An APL-like programming language. Self-hosted!
LEAP An ALGOL-based associative language. A high level programming language for large, complex associative structures has been designed and implemented. The underlying data structure has been implemented using a hash-coding technique. The discussion includes a comparison with other work and examples of applications of the language.
Ion Amazon Ion is a richly-typed, self-describing, hierarchical data serialization format offering interchangeable binary and text representations. The text format (a superset of JSON) is easy to read and author, supporting rapid prototyping. The binary representation is efficient to store, transmit, and skip-scan parse.
Alma Alma is a small language created as a testbed for Raku macros.
Scrapscript All programs are data, expressions are content-addressable "scraps".Scrapscript rejects traditional package-management. Instead, “scrapyards” combine features from Smalltalk, Hackage, IPFS, GitHub, and StackOverflow.
albatross Albatross is A Programming Language with Static Verification: You can develop programs and algorithms and prove them to be correct in Albatross
Aith Aith is a perfomant systems programming language with am empathises on type systems. As of now Aith is very early stages and very little is implemented.
ICML Adobe InDesign file format.
EverParse3D Addressing this need, we present EverParse3D, a parser generator for binary message formats that yields performant C code backed by fully automated formal proofs of memory safety, arithmetic safety, functional correctness, and even double-fetch freedom to prevent certain kinds of time-of check/time-of-use errors. This allows systems developers to specify their message formats declaratively and to integrate correct-by-construction C code into their applications, eliminating several classes of bugs. EverParse3D has been in use in the Windows kernel for the past year. Applied primarily to the Hyper-V network virtualization stack, the formats of nearly 100 different messages spanning four protocols have been specified in EverParse3D and the resulting formally proven parsers have replaced prior handwritten code.
ActivityPub ActivityPub is an open, decentralized social networking protocol based on Pump.io's ActivityPump protoco
Cone Acorn2's passion is the 3D web and his Pegasus3D browser, and the web is powered by languages. His Cone language powers the 3D web. Cone is statically-typed, and uses LLVM to generate native efficient executables. Cone will also be a test bed for implementing gradual memory management. His previous work, Acorn is a dynamic language with some of the same features.
Acme Acme is a simple, generic software architecture description language (ADL) that can be used as a common interchange format for architecture design tools and/or as a foundation for developing new architectural design and analysis tools. This site provides an introduction to Acme along with a collection of useful Acme software and technical information.
Ace Editor Ace is an embeddable code editor written in JavaScript. It matches the features and performance of native editors such as Sublime, Vim and TextMate. It can be easily embedded in any web page and JavaScript application. Ace is maintained as the primary editor for Cloud9 IDE and is the successor of the Mozilla Skywriter (Bespin) project.
spir-v Abstract. SPIR-V is a new platform-independent intermediate language. It is a self-contained, fully specified, binary format for representing graphical-shader stages and compute kernels for multiple APIs. Physically, it is a stream of 32-bit words. Logically, it is a header and a linear stream of instructions. These encode, first, a set of annotations and decorations, and second a collection of functions. Each function encodes a control-flow graph (CFG) of basic blocks, with additional instructions to preserve source-code structured flow control. Load/store instructions are used to access declared variables, which includes all input/output (IO). Intermediate results bypassing load/store use single static-assignment (SSA) representation. Data objects are represented logically, with hierarchical type information: There is no flattening of aggregates or assignment to physical register banks, etc. Selectable addressing models establish whether general pointers may be used, or if memory access is purely logical.
Aardvark Aardvark is an object oriented programming language designed writing clean and easy to read code. It is an interpreted language written in C++, Go, and Python. Version 0.1~0.8.9 was written in Python, Version 1.0 was written in C++, and AdkGO was written in Go. It has a UI, graphics, and data science/artificial intellegence library as of 2022.
ALGOL 60 ALGOL 60 (short for Algorithmic Language 1960) is a member of the ALGOL family of computer programming languages. It followed on from ALGOL 58 which had introduced code blocks and the begin and end pairs for delimiting them. ALGOL 60 was the first language implementing nested function definitions with lexical scope. It gave rise to many other programming languages, including CPL, Simula, BCPL, B, Pascal and C.
AIMMS AIMMS (an acronym for "Advanced Interactive Multidimensional Modeling System") began as a software system designed for modeling and solving large-scale optimization and scheduling-type problems. AIMMS is considered to be one of the five most important algebraic modeling languages and the creator (Johannes J. Bisschop) has been awarded with INFORMS Impact Prize for his work in this language.
adam-standard ADaM defines dataset and metadata standards that support: efficient generation, replication, and review of clinical trial statistical analyses, and traceability among analysis results, analysis data, and data represented in the Study Data Tabulation Model (SDTM).​
abs ABS is a programming language that works best when you're scripting on your terminal. It tries to combine the elegance of languages such as Python, or Ruby with the convenience of Bash.
snakemake A workflow is defined in a ‘Snakefile’ through a domain-specific language that is close to standard Python syntax. It consists of rules that denote how to create output files from input files. The workflow is implied by dependencies between the rules that arise from one rule needing an output file of another as an input file.
Timpani A very small markup language for inline styling supporting:
Virt A universal programming language
GraphQL Schema Definition Language A type definition syntax to the GraphQL specification.
Interleaved Notation A two-dimensional notation for programs, comprising alternating rows of functions and operands with arguments and return values indicated by physical layout,and a tool for interactive live editing of programs in this notation.
Relational Data File A tool for mechanized inference execution and data retrieval.
Superjson A superset of JSON adding: undefined bigint Date RegExp Set Map Error
Tick C A superset of ANSI C that allows high-level, efficient, and machine-independent specification of dynamically generated code.
souper A superoptimizer for LLVM IR
Filterscript A subset of RenderScript
OWL DL A subset of OWL.
Koka A strongly typed functional-style language with effect types and handlers.
commonmark A strongly defined, highly compatible specification of Markdown
Tao A statically-typed functional language with polymorphism, typeclasses, sum types, pattern-matching, first-class functions, currying, good diagnostics, and much more!
hacspec A specification language for crypto primitives and more in Rust.
Ghidra A software reverse engineering (SRE) suite of tools developed by NSA's Research Directorate in support of the Cybersecurity mission
buzz A small/lightweight typed scripting language (in development)
Kamby A small, embeddable and convenient language for who want to use and understand what is happening behind the scenes. The core is just ~400LOC and binary has just 20kb
sporth A small stack-based audio language.
Slope A small s-expression based programming language
Formatted Table A simple plain text format for storing tabular data.
npy A simple format for saving numpy arrays to disk with the full information about them. The .npy format is the standard binary file format in NumPy for persisting a single arbitrary NumPy array on disk.
gitignore A simple application specific language used to tell git which files to ignore.
Mond A scripting language for C# which can be embedded in Lua-like manner.
flexbuffers A schemaless binary encoding. This is a binary format that can be used in conjunction with FlatBuffers (by storing a part of a buffer in FlexBuffers format), or also as its own independent serialization format.
Robots.txt A robots.txt file tells search engine crawlers which URLs the crawler can access on your site.
Zeta A prototype implementation of xoc in zeta, a C-like interpreted procedural language with first-class functions. Zeta makes writing extensions easier than standard C, although extension writers must adjust to a slightly different language. Our implementation runs zeta using a bytecode interpreter and is therefore limited in its performance; we plan to replace the bytecode interpreter with compilation to machine code, which should reduce the compilation time for a large program from tens of seconds to a fraction of a second.
mycroft A prolog-like language with compound truth value logic
zolang A programming language to generate code for multiple platforms
Fun A programming language for the realtime web.
Perfectscript A programming language for the office suite.
Gren A programming language for simple and correct applications
Netscript A programming language for packet-stream processing
EXPLAN A programming language for complex visual stimuli presentation.
Zig A programming language designed for robustness, optimality, and clarity.
sill A programming language based on the intuitionistic linear logic view of session types.
progsbase A programming language and tooling for timeless programming. Programs written in progsbase can be reused across time and space. Code written in progsbase can currently be translated to 13 other languages, but many more can be supported.
comm A procedural language with integer arithmetic, local variables, conditional statements, while loops and print, compiled to simple machine code.
Dern A platform independent programming language in standard C99. It is a dialect of Lisp with influences from Scheme, Emacs Lisp and C. Runs in Amiga, Haiku, Plan9, Unix, Windows and almost anything between.
SCROLL A pattern recording language.
Observable A partially open source derivative of Javascript modified for dataflow that powers the Observable data science web app.
domino A packet transaction is a block of code written in an imperative language called Domino.
fetlang A nsfw esolang.
Brainfuck A nsfw esolang.
ROOT A modular scientific software toolkit. It provides all the functionalities needed to deal with big data processing, statistical analysis, visualisation and storage. It is mainly written in C++ but integrated with other languages such as Python and R.
Tree Notation A minimalist notation consisting of just the word break rule and the off-side rule.
son A minimal subset of JSON for machine-to-machine communication
kivy-lang A meta language that look like QML in QT
kitlang A magical, high performance programming language for game development.
wisp A little Clojure-like LISP in JavaScript
Slim A lightweight templating engine
Sublime Syntax Test Lang A language for testing sublime syntax files.
TQL A language for querying TrueBases.
One-man-language A language for a dissertation. Miceli, James J. Some Experiences with a One-man Language. Diss. University of Toronto, Department of Computer Science, 1977.
darklang A language built for deployless backends
KB A knowledge representation package for Common Lisp
lispyscript A javascript With Lispy Syntax And Macros!
iota A highly interactive programming system is presented which supports hierarchical and modular program development with abstraction mechanisms. By taking advantage of abstraction mechanisms, the system provides a "truly modular" environment, in which modules are constructed, debugged, verified, and compiled in a module-by-module fashion. Such an environment naturally requires system management of the information concerning ongoing program development, in the form of module databases. As a result, further problems arise as to how to modify the information in efficient and consistent ways. This paper discusses design objectives for modular programming systems by focusing on such issues as information management, interactive construction and modification of modules, separate processing, specification and verification, and supports for cooperative program development.
Lorel A high level language for processing n-ary relations.
C Header Files A header file is a file containing C declarations and macro definitions (see Macros) to be shared between several source files. You request the use of a header file in your program by including it, with the C preprocessing directive ‘#include’.
METAPOST A graphics language that can output PostScript, SVG, and some other formats.
zlang A flexible dynamically-typed programming language running on the JVM and supporting access to Java objects and interaction with Java at runtime.
forest-database A filestore is a structured collection of data files housed in a conventional hierarchical file system. Many applications use filestores as a poor-man’s database, and the correct execution of these applications requires that the collection of files, directories, and symbolic links stored on disk satisfy a variety of precise invariants. Moreover, all of these structures must have acceptable ownership, permission, and timestamp attributes. Unfortunately, current programming languages do not provide support for documenting assumptions about filestores, detecting errors, or safely loading from and storing to them. This paper describes the design, implementation, and semantics of Forest, a novel domain-specific language for describing filestores. The language uses a type-based metaphor to specify the expected structure, attributes, and invariants of filestores. Forest generates loading and storing functions that make it easy to connect data on disk to an isomorphic representation in memory that can be manipulated as if it were any other data structure. Forest also generates metadata that describes the degree to which the structures on the disk conform to the specification, making error detection easy. Hence, in a nutshell, Forest extends the rigorous discipline of typed programming languages and many of their benefits to the untyped world of file systems. We have implemented Forest as an embedded domain-specific language in Haskell. In addition to generating infrastructure for reading, writing and checking file systems, our implementation generates a type class instances that make it easy to build generic tools that operate over arbitrary filestores. We illustrate the utility of this infrastructure by building a file system visualizer, a file access checker, a generic query interface, description-directed variants of several standard UNIX shell tools and (circularly) a simple Forest description inference engine. Finally, we formalize a core fragment of Forest in a semantics inspired by classical tree logics and prove round-tripping laws showing that the loading and storing functions behave sensibly.
lever A dynamically typed language built to absorb features from other languages.
m3db A distributed time series database.
Hy A dialect of Lisp that's embedded in Python
zish A data serialization format, designed to be an improvement on JSON. It adds timestamp, bytes and decimal types, as well as multi-line strings.
Forml A contemporary programming language for the discriminating programmer, intended to approximate the safety of Haskell and the expressiveness of Ruby. Should such an approximation turn out to exist.
Xidoc A consistent markup language
Manim A community-maintained Python framework for creating mathematical animations
Oracle Java A commercial implementation of Java provided by Oracle Corporation.
Scoop A command-line installer for Windows
Adept A blazing fast language for general purpose programming.
bag-format A bag is a file format in ROS for storing ROS message data. Bags -- so named because of their .bag extension -- have an important role in ROS, and a variety of tools have been written to allow you to store, process, analyze, and visualize them.
BridgeTalk A Visual Programming Language for Novices
Zuo A Tiny Racket for Scripting
StruQL A StruQL query is a function from a set of input graphs to an output graph.
chibicc A Small C Compiler.
SIL A Simulation Language
klong A Simple Array Language. Klong is an array language, like K, but without the ambiguity. If you know K or APL, you may be disappointed by Klong. If you don't know any array languages, it might explode your brain. Use at your own risk!
UnQL A Query Language and Algebra for Semistructured Data Based on Structural Recursion
Myghty A Python-based template and view-controller framework derived from HTML::Mason. Supports the full featureset of Mason, allowing component-based web development with Python-embedded HTML, and includes many new concepts and features not found in Mason. Myghty is a legacy library. New projects should use Mako templates.
kima A Programming Language with static types and (currently WIP) algebraic effects.
Whiley A Programming Language with Extended Static Checking
arrow A Modern Reversible Programming Language. Reversible programming languages are those whose programs can be run backwards as well as forwards. This condition impacts even the most basic constructs, such as =, if and while. I discuss Janus, the first imperative reversible programming language, and its limitations. I then introduce Arrow, a reversible language with modern features, including functions.
taf A Lisp with row polymorphism, delimited continuations, and hygienic macros. [vaporware]
Scenic A Language for Scenario Specification and Scene Generation. We propose a new probabilistic programming language for the design and analysis of perception systems, especially those based on machine learning. Specifically, we consider the problems of training a perception system to handle rare events, testing its performance under different conditions, and debugging failures. We show how a probabilistic programming language can help address these problems by specifying distributions encoding interesting types of inputs and sampling these to generate specialized training and test sets. More generally, such languages can be used for cyber-physical systems and robotics to write environment models, an essential prerequisite to any formal analysis. In this paper, we focus on systems like autonomous cars and robots, whose environment is a scene, a configuration of physical objects and agents. We design a domain-specific language, Scenic, for describing scenarios that are distributions over scenes. As a probabilistic programming language, Scenic allows assigning distributions to features of the scene, as well as declaratively imposing hard and soft constraints over the scene. We develop specialized techniques for sampling from the resulting distribution, taking advantage of the structure provided by Scenic's domain-specific syntax. Finally, we apply Scenic in a case study on a convolutional neural network designed to detect cars in road images, improving its performance beyond that achieved by state-of-the-art synthetic data generation methods.
flux-lang A Language for Programming High-Performance Servers
lambda-obliv A Language for Probabilistically Oblivious Computation. An oblivious computation is one that is free of direct and indirect information leaks, e.g., due to observable differences in timing and memory access patterns. This paper presents λobliv, a core language whose type system enforces obliviousness. Prior work on type-enforced oblivious computation has focused on deterministic programs. λobliv is new in its consideration of programs that implement probabilistic algorithms, such as those involved in cryptography. λobliv employs a substructural type system and a novel notion of probability region to ensure that information is not leaked via the observed distribution of visible events. Probability regions support reasoning about probabilistic correlation and independence between values, and our use of probability regions is motivated by a source of unsoundness that we discovered in the type system of ObliVM, a language for implementing state of the art oblivious algorithms.
CDL A Language for Cellular Processing. Our goal is to describe complex cellular automata in a concise and readable way.
jsparagus A JavaScript parser written in Rust
Tea A High-level Language and Runtime System for Automating Statistical Analysis. Tea is implemented as an open-source Python library, so programmers can use Tea wherever they use Python, including within Python notebooks.
Seq A High-Performance Language for Bioinformatics. Here, we introduce Seq, the first language tailored specifically to bioinformatics, which marries the ease and productivity of Python with C-like performance. Seq is a subset of Python—and in many cases a drop-in replacement—yet also incorporates novel bioinformatics- and computational genomics-oriented data types, language constructs and optimizations. Seq enables users to write high-level, Pythonic code without having to worry about low-level or domain-specific optimizations, and allows for seamless expression of the algorithms, idioms and patterns found in many genomics or bioinformatics applications. On equivalent CPython code, Seq attains a performance improvement of up to two orders of magnitude, and a 175× improvement once domain-specific language features and optimizations are used. With parallelism, we demonstrate up to a 650× improvement. Compared to optimized C++ code, which is already difficult for most biologists to produce, Seq frequently attains up to a 2× improvement, and with shorter, cleaner code. Thus, Seq opens the door to an age of democratization of highly-optimized bioinformatics software.
XML-GL A Graphical Language for Querying and Reshaping XML Documents. XML-GL is not a visual interface over a conventional, textual query language, but a graph-based query language with both its syntax and semantics defined in terms of graph structures and operations.
thune A Forth inspired language using a datatype and context system derived from Orca.
QOIR A Fast, Simple, Lossless Image File Format based on QOI ( http://qoiformat.org )
datev A Domain-Specific Language for Payroll Calculations
mountain A (hopefully) fast, C compatible, language designed to enable greatness
kasaya A "WYSIWYG" (kind of) scripting language and runtime for browser automation
libsvm-format [ :]*
pisc PISC attempts to make concatenative programming less mind-bendy via pervasive use of locals, closures, the smallest set of syntax hacks to make code look nice. PISC is a stack-based programming language that is primarily inspired by factor, TCL, bash and a little bit of python, written in go.
tarot Tarot A self-hosted scheme compiler (to qcode) and virtual machine.
myrddin Myrddin is a systems programming language. Myrddin emphasizes control, simplicity, a clear mental model and predictable, transparent behavior. It features strong type checking, generics, type inference, closures, and traits. It aims to fit a similar niche as C, but with fewer bullets in your feet.
Ad-hoc Ad-hoc is an experimental programming language currently supporting the following features: first-class functions, immutability, lambda terms, recursion, closures, strict and non-strict evaluation, lexical and dynamic scopes, and deep binding.
elegance Elegance Objected oriented language aiming for high type-safety and readability.
monte Monte is a dynamic programming language inspired by Python and E.
icarus Icarus is a minimum-viable type-safe imperative language designed to serve as a platform for exploring mutation and general side-effect control.
psyche-c Psyche-c is a compiler for incomplete C code. It features a Hindley/Milner-inspired type inference engine for C.
Ante Ante is a compiled systems language focusing on providing extreme extensibility through the use of a compile-time API. Using such an API, compiler extensions can be created within the program itself, allowing for the addition of a garbage collector, ownership system, type system changes, etc.
NGS NGS - Next Generation Shell, a language (and a shell in the future) for ops tasks. NGS aims to be an alternative for both bash/Python/Ruby/Perl/Go and configuration management tools. It has syntax for the common operations and libraries (currently only AWS) for idempotent resources manipulation. NGS unique features include built in exit code handling and syntax for run-a-command-and-parse-output.
Gwion Gwion is a strongly-timed musical programming language .
inko Inko is a gradually typed, interpreted, object-oriented programming language drawing inspiration from languages such as Smalltalk, Self, Ruby, Erlang and Rust.
popr Popr applies concatenative programming to types as well as values, striving for purity and correctness, and efficient execution.
juicy Juicy is a low-level, compiled, purely functional, highly generic language with inferred types and tail recursion.
dyvil Dyvil is a multi-paradigm, general purpose programming language that is based on Java and the JVM. It is a compiled, statically and strongly typed language that supports object-oriented, functional and imperative programming styles. The language features many high-level constructs as well as an extensible and expressive syntax, making it highly useful for both rapid and safe prototyping, and the creation of domain-specific languages.
starpial Starpial is a stack-oriented functional logic programming language with OOP, recursive regex, dependent types, refinement types, and automatic parallelization based on transactions.
Futhark Futhark, a high-performance parallel functional array language targeting GPUs.
fox Fox is an ever-evolving experiment in declarativeness that strives to one day settle on a consistent syntax.
egel Egel An interpreter for eager untyped combinator rewriting implemented in C++.
juniper Juniper is a functional reactive programming language for the Arduino and other related platforms.
nylo Nylo: any task in one line of code
plasma Plasma, which aims to strike a balance between functional and imperative programming, include state-of-the-art concurrent programming features and feature automatic parallelisation. Boney previously worked on Mercury a logic language.
kitten Kitten is a statically typed concatenative language with effect types.
oopsilon Oopsilon is an object-oriented language in the Kayian tradition which is (perhaps uniquely) founded on a negativist philosophy drawing on critical theory and stressing the importance of hermeneutics in understanding the problems programmers experience.
8th 8th is an innovative, secure, cross-platform, robust, and fun concatenative programming language for mobile, desktop, server, and embedded application development.
3DS 3DS is one of the file formats used by the Autodesk 3ds Max 3D modeling, animation and rendering software.
noulith *slaps roof of [programming language]* this bad boy can fit so much [syntax sugar] into it
NCAR Command Language (The NCAR Command Language (NCL), a product of the Computational & Information Systems Laboratory at the National Center for Atmospheric Research (NCAR) and sponsored by the National Science Foundation, is a free interpreted language designed specifically for scientific data processing and visualization.
reStructuredText "reStructuredText" is ONE word, not two! reStructuredText is an easy-to-read, what-you-see-is-what-you-get plaintext markup syntax and parser system. It is useful for in-line program documentation (such as Python docstrings), for quickly creating simple web pages, and for standalone documents. reStructuredText is designed for extensibility for specific application domains. The reStructuredText parser is a component of Docutils. reStructuredText is a revision and reinterpretation of the StructuredText and Setext lightweight markup systems.
Speedie "General-purpose modern and clean object-oriented programming language."
tetruss-app a suite of computer programs used for fluid dynamics and aerodynamics analysis and design.
Yedalog We introduce Yedalog, a declarative programming language that allows programmers to mix data-parallel pipelines and computation seamlessly in a single language. By contrast, most existing tools for data-parallel computation embed a sublanguage of data-parallel pipelines in a general-purpose language, or vice versa. Yedalog extends Datalog, incorporating not only computational features from logic programming, but also features for working with data structured as nested records. Yedalog programs can run both on a single machine, and distributed across a cluster in batch and interactive modes, allowing programmers to mix different modes of execution easily.
FuzzyCLIPS The modifications made to CLIPS contain the capability of handling fuzzy concepts and reasoning. It enables domain experts to express rules using their own fuzzy terms. It allows any mix of fuzzy and normal terms, numeric-comparison logic controls, and uncertainties in the rules and facts. Fuzzy sets and relations deal with fuzziness in approximate reasoning, while certainty factors for rules and facts manipulate the uncertainty.
guru OpTT has been implemented in the GURU verified programming language, which includes a type- and proof-checker, and a compiler to efficient C code. In addition to the core OpTT, GURU implements a number of extensions, including ones for verification of programs using mutable state and input/output. This paper gives an introduction to verified programming in GURU.
vdscript A video capture utility for 32-bit and 64-bit Windows platforms
Djot A light markup language

Results as JSON, CSV, TSV or Tree

View source

- Build the next great programming language · Search · Add Language · Features · Creators · Resources · About · Blog · Acknowledgements · Stats · Sponsor · Traffic · Traffic Today · Day 277 · feedback@pldb.com · Logout