pldb/PLDB huggingface dataset:
Kawa (pl, appeared 1996)
Creators: Per Bothner
Origin: GNU Project
Country: United States


Kawa  is a language framework written in the programming language Java that implements the programming language Scheme, a dialect of Lisp, and can be used to implement other languages to run on the Java virtual machine (JVM). It is a part of the GNU Project. The name Kawa comes from the Polish word for coffee; a play on words, since Java is another familiar name for coffee.
kayia (pl, appeared 1999)
Creators: David Broderick
Origin: https://kayia.com
Country: United States
Czech Republic
Website: https://kayia.com/

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.
Keras (library, appeared 2015)
Creators: François Chollet
Origin: https://github.com/keras-team
Country: United States
Website: https://keras.io/


Keras is an open source neural network library written in Python. It is capable of running on top of TensorFlow, Microsoft Cognitive Toolkit, or Theano. Designed to enable fast experimentation with deep neural networks, it focuses on being user-friendly, modular, and extensible. It was developed as part of the research effort of project ONEIROS (Open-ended Neuro-Electronic Intelligent Robot Operating System), and its primary author and maintainer is François Chollet, a Google engineer. In 2017, Google's TensorFlow team decided to support Keras in TensorFlow's core library. Chollet explained that Keras was conceived to be an interface rather than a standalone machine-learning framework. It offers a higher-level, more intuitive set of abstractions that make it easy to develop deep learning models regardless of the computational backend used. Microsoft added a CNTK backend to Keras as well, available as of CNTK v2.0.

GitHub description: Deep Learning for humans
kerf (pl, appeared 2015)
Creators: Kevin Lawler
Origin: https://github.com/kevinlawler/kerf/issues
Country: United States

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.


GitHub description: Kerf

[100] + [0, 10, 20]
Agilent VEE (pl, appeared 1991)
Origin: Keysight Technologies
Country: United States
Website: http://www.keysight.com/find/vee


Keysight VEE is a graphical dataflow programming software development environment from Keysight Technologies for automated test, measurement, data analysis and reporting. VEE originally stood for Visual Engineering Environment and developed by HP designated as HP VEE; it has since been officially renamed to Keysight VEE. Keysight VEE has been widely used in various industries, serving the entire stage of a product lifecycle, from design, validation to manufacturing. It is optimized in instrument control and automation with test and measurement devices such as data acquisition instruments like digital voltmeters and oscilloscopes, and source devices like signal generators and programmable power supplies.
KiCad Legacy Layout (application, appeared 1992)
Origin: Instituts Universitaires de Technologie de Grenoble
Country: France
File extensions: sch
lib
brd
kicad_pcb
kicad_wks
kicad_mod

KiCad writes all files in human readable ASCII. This makes manipulation by hand and scripting very easy.

KiCad (pronounced "Key-CAD") is a free software suite for electronic design automation (EDA). It facilitates the design of schematics for electronic circuits and their conversion to PCB designs. KiCad was originally developed by Jean-Pierre Charras. It features an integrated environment for schematic capture and PCB layout design. Tools exist within the package to create a bill of materials, artwork, Gerber files, and 3D views of the PCB and its components.


(kicad_pcb (version 3)
 (host pcbnew "(2013-02-20 BZR 3963)-testing")
  (general
  (links 2)
  (no_connects 0)
  (area 57.924999 28.924999 74.075001 42.075001)
  (thickness 1.6)
  (drawings 5)
  (tracks 5)
  (zones 0)
  (modules 2)
  (nets 3)
))
Kid templating language (template, appeared 1999)
Origin: https://sourceforge.net/projects/kid-template/lists/kid-template-discuss
Country: Germany and United States


Kid is a simple template engine for XML-based vocabularies written in Python. Kid claims to have many of the best features of XSLT, TAL, and PHP, but "with much of the limitations and complexity stamped out". Kid initially acted as the View component of the TurboGears framework in the framework's version 1.x implementation; however, the TurboGears project team has since replaced it with Genshi, citing perceived performance advantages.Kid is used by the Fedora Project in the repoview utility  which creates a set of static HTML pages within a YUM repository.
kilo-lisp (pl, appeared 2019)
Also known as: klisp
Origin: https://www.t3x.org
Country: Germany
Website: https://www.t3x.org/klisp/index.html

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



((a . b) . c)
(a . (b . c))
((a . b) . (c . d))
kitten (pl, appeared 2012)
Creators: Jon Purdy
Origin: https://github.com/evincarofautumn/kitten/issues
Country: United States
Website: http://kittenlang.org/

<a href='http://kittenlang.org'>Kitten</a> is a statically typed concatenative language with effect types.


GitHub description: A statically typed concatenative systems programming language.
Klerer-May System (pl, appeared 1964)
Origin: Columbia University
Country: United States


The Klerer–May System is a programming language developed in the mid-1960s, oriented to numerical scientific programming, whose most notable feature is its two-dimensional syntax based on traditional mathematical notation.  For input and output, the Klerer–May system used a Friden Flexowriter modified to allow half-line motions for subscripts and superscripts. The character set included digits, upper-case letters, subsets of 14 lower-case Latin letters and 18 Greek letters, arithmetic operators (+ − × / |) and punctuation (. , ( )), and eight special line-drawing characters (resembling  ╲ ╱ ⎜ _ ⎨ ⎬ ˘ ⁔) used to construct multi-line brackets and symbols for summation, products, roots, and for multi-line division or fractions. The system was intended to be forgiving of input mistakes, and easy to learn; its reference manual was only two pages.The system was developed by Melvin Klerer and Jack May at Columbia University's Hudson Laboratories in Dobbs Ferry, New York, for the Office of Naval Research, and ran on GE-200 series computers.
klong (pl, appeared 2015)
Origin: https://t3x.org/klong/
Country: Germany
Website: http://t3x.org/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!



{&/x!:\2+!_x^1%2}
KML (xmlFormat, appeared 2007)
Stands for: Keyhole Markup Language
Origin: Keyhole, Inc
Google
Country: United States


Keyhole Markup Language (KML) is an XML notation for expressing geographic annotation and visualization within Internet-based, two-dimensional maps and three-dimensional Earth browsers. KML was developed for use with Google Earth, which was originally named Keyhole Earth Viewer. It was created by Keyhole, Inc, which was acquired by Google in 2004. KML became an international standard of the Open Geospatial Consortium in 2008. Google Earth was the first program able to view and graphically edit KML files. Other projects such as Marble have also started to develop KML support.
Knitr (template, appeared 2012)
Origin: Iowa State University
Country: United States


knitr is an engine for dynamic report generation with R. It is a package in the statistical programming language R that enables integration of R code into LaTeX, LyX, HTML, Markdown, AsciiDoc, and reStructuredText documents. The purpose of knitr is to allow reproducible research in R through the means of Literate Programming. It is licensed under the GNU General Public License.knitr was inspired by Sweave and written with a different design for better modularization, so it is easier to maintain and extend. Sweave can be regarded as a subset of knitr in the sense that all features of Sweave are also available in knitr. Some of knitr's extensions include the R Markdown format (used in reports published on RPubs), caching, TikZ graphics and support to other languages such as Python, Perl, C++, Shell scripts and CoffeeScript, and so on. knitr is officially supported in the RStudio IDE for R, LyX, Emacs/ESS and the Architect IDE for data science.
Knowledge Interchange Format (pl, appeared 1990)
Also known as: kif
Origin: http://www-ksl.stanford.edu/knowledge-sharing/
Country: United States


Knowledge Interchange Format (KIF) is a computer language designed to enable systems to share and re-use information from knowledge-based systems. KIF is similar to frame languages such as KL-One and LOOM but unlike such language its primary role is not intended as a framework for the expression or use of knowledge but rather for the interchange of knowledge between systems. The designers of KIF likened it to PostScript. PostScript was not designed primarily as a language to store and manipulate documents but rather as an interchange format for systems and devices to share documents. In the same way KIF is meant to facilitate sharing of knowledge across different systems that use different languages, formalisms, platforms, etc. KIF has a declarative semantics. It is meant to describe facts about the world rather than processes or procedures. Knowledge can be described as objects, functions, relations, and rules. It is a formal language, i.e., it can express arbitrary statements in first order logic and can support reasoners that can prove the consistency of a set of KIF statements. KIF also supports non-monotonic reasoning. KIF was  created by Michael Genesereth, Richard Fikes and others participating in the DARPA knowledge Sharing Effort.Although the original KIF group intended to submit to a formal standards body, that did not occur.  A later version called Common Logic has since been developed for submission to ISO and has been approved and published. A variant called SUO-KIF is the language in which the Suggested Upper Merged Ontology is written.
Kodu Game Lab (pl, appeared 2009)
Origin: Microsoft's Future Social Experiences Labs
Country: United States
Website: http://kodugamelab.com


Kodu, originally named Boku, is a programming integrated development environment (IDE) by Microsoft's FUSE Labs. It runs on Xbox 360 and Microsoft Windows XP, Windows Vista, Windows 7, Windows 8 and Windows 10. It was released on the Xbox Live Marketplace on June 30, 2009. A Windows version is available to the general public for download from Microsoft's FUSE web portal.
kogut (pl, appeared 2004)
Origin: https://sourceforge.net/p/kokogut/mailman/kokogut-users/
Country: Poland
Website: http://kokogut.sourceforge.net/kogut.html

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.
Koka (pl, appeared 2012)
Creators: Daan Leijen
Origin: Microsoft Research
Country: United States
Website: https://www.microsoft.com/en-us/research/project/koka/?from=http%3A%2F%2Fresearch.microsoft.com%2Fen-us%2Fprojects%2Fkoka
Keywords: infix
infixr
infixl
type
cotype
rectype
alias
struct
con
fun
function
val
var
external
if
then
else
elif
return
match
private
public
private
module
import
as
include
inline
rec
try
yield
enum
interface
instance

A strongly typed functional-style language with effect types and handlers.


GitHub description: Koka language compiler and interpreter

fun hello-ten()
  var i := 0
  while { i < 10 }
    println("hello")
    i := i + 1
kona (pl, appeared 2010)
Origin: https://github.com/kevinlawler/kona/issues
Country: United States

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.


GitHub description: Open-source implementation of the K programming language

factorial:{*/1+!:x}
fib1:{(x(|+\)\1 1)[;1]}
fib2:{x{x,+/-2#x}/!2}
fib_rec:{:[x<2;1;_f[x-1]+_f[x-2]]}
maxsubsum:{|/0(0|+)\x}
primes_to_n_sieve:{2_&{:[x@y;x&@[1,-1_ z#(1_ y#1),0;y;:;1];x]}/[x#1;2_!__ceil_sqrt x;x]}
primes_to_n_sieve2:{:[x<4;,2;r,1_&~|/x#'~!:'r: _f[_ _ceil _sqrt x]]}
KonsolScript (pl, appeared 2005)
Origin: https://sourceforge.net/p/konsolscript/feature-requests/
Country: Canada


KonsolScript is a cross-platform scripting language used mostly for games. It is available for Windows and Linux Operating Systems. KonsolScript was developed during 2005 as the scripting language which is intentionally  for the purpose writing games with KAGE (Alternative Game Engine). However, its interpreter, Quixie, can also be used as common gateway interface for serving web pages. KonsolScript's language design is greatly inspired by C programming language and VergeC, although its drawing API is inspired by ActionScript. Together with KAGE, KonsolScript was distributed as freeware until it was released as free software in SourceForge on April 2006. KonsolScript is licensed under GNU General Public License.
Korn shell (pl, appeared 1983)
Also known as: ksh
Origin: https://github.com/att
Country: United States
Website: http://www.kornshell.org/


KornShell (ksh) is a Unix shell which was developed by David Korn at Bell Labs in the early 1980s and announced at USENIX on July 14, 1983. The initial development was based on Bourne shell source code. Other early contributors were Bell Labs developers Mike Veach and Pat Sullivan, who wrote the Emacs and vi-style line editing modes' code, respectively. KornShell is backward-compatible with the Bourne shell and includes many features of the C shell, inspired by the requests of Bell Labs users.
Kotlin (pl, appeared 2011)
Creators: Andrey Breslav
Origin: JetBrains
Website: https://kotlinlang.org
File extensions: kt
kts
Keywords: as
as?
break
class
continue
do
else
false
for
fun
if
in
!in
interface
is
!is
null
object
package
return
super
this
throw
true
try
typealias
val
var
when
while
by
catch
constructor
delegate
dynamic
field
file
finally
get
import
init
param
property
receiver
set
setparam
where
actual
abstract
annotation
companion
const
crossinline
data
enum
expect
external
final
infix
inline
inner
internal
lateinit
noinline
open
operator
out
override
private
protected
public
reified
sealed
suspend
tailrec
vararg
field
it
+
-
*
/
%
*
=
+=
-=
*=
/=
%=
++
--
&&
||
!
==
!=
===
!==
<
>
<=
>=
[
]
!!
?.
?:
::
..
:
?
->;
@
;
$
_


Kotlin is a statically-typed programming language that runs on the Java virtual machine and also can be compiled to JavaScript source code or use the LLVM compiler infrastructure. Its primary development is from a team of JetBrains programmers based in Saint Petersburg, Russia. While the syntax is not compatible with Java, Kotlin is designed to interoperate with Java code and is reliant on Java code from the existing Java Class Library, such as the collections framework. As of Android Studio 3.0 (Beta version) Kotlin is a fully supported programming language on Android and lets the user choose between targeting Java 6- or Java 8-compatible bytecode.

GitHub description: The Kotlin Programming Language.
Knowledge Query and Manipulation Language (queryLanguage, appeared 1993)
Stands for: Knowledge Query and Manipulation Language
Origin: Defense Advanced Research Projects Agency
Country: United States


The Knowledge Query and Manipulation Language, or KQML, is a language and protocol for communication among software agents and knowledge-based systems. It was developed in the early 1990s part of the DARPA knowledge Sharing Effort, which was aimed at developing techniques for building large-scale knowledge bases which are shareable and reusable. While originally conceived of as an interface to knowledge based systems, it was soon repurposed as an Agent communication language.Work on KQML was led by Tim Finin of the University of Maryland, Baltimore County and  Jay Weber of EITech and involved contributions from many researchers. The KQML message format and protocol can be used to interact with an intelligent system, either by an application program, or by another intelligent system. KQML's "performatives" are operations that agents perform on each other's knowledge and goal stores. Higher-level interactions such as contract nets and negotiation are built using these. KQML's "communication facilitators" coordinate the interactions of other agents to support knowledge sharing.  Experimental prototype systems support concurrent engineering, intelligent design, intelligent planning, and scheduling. KQML is superseded by FIPA-ACL.
KRC (pl, appeared 1981)
Stands for: Kent Recursive Calculator
Creators: David Turner
Origin: University of Kent
Country: United Kingdom


KRC (Kent Recursive Calculator) is a lazy functional language developed by David Turner from November 1979 to October 1981 based on SASL, with pattern matching, guards and ZF expressions (now more usually called list comprehensions). Two implementations of KRC were written: David Turner's original one in BCPL running on EMAS, and Simon J. Croft's later one in C under Unix, and KRC was the main language used for teaching functional programming at the University of Kent at Canterbury (UK) from 1982 to 1985. The direct successor to KRC is Miranda, which includes a polymorphic type discipline based on that of Milner's ML.
KRL (pl, appeared 1976)
Stands for: knowledge representation language
Creators: Daniel G. Bobrow
Terry Winograd
Origin: Xerox PARC
Stanford University
Country: United States


KRL is a knowledge representation language, developed by Daniel G. Bobrow and Terry Winograd while at Xerox PARC and Stanford University, respectively. It is a frame-based language.   KRL was an attempt to produce a language which was nice to read and write for the engineers who had to write programs in it, processed like human memory, so you could have realistic AI programs, had an underlying semantics which was firmly grounded like logic languages, all in one, all in one language. And I think it - again, in hindsight - it just bogged down under the weight of trying to satisfy all those things at once.


ruleset sample {
  meta {
    name "Hello World"
    description <<
Hello world
>>
    author "Phil Windley"
  }

  // just one rule
  rule hello {
    select when web pageview
    notify("Hello world!", "Just a note to say hello");
  }
}
kumir (pl, appeared 2011)
Origin: https://github.com/a-a-maly/kumir2/issues
Country: Russia
Website: https://www.niisi.ru/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 (КуМир - Комплект Учебных МИРов).


GitHub description: New home for Kumir2.
L6 (pl, appeared 1963)
Origin: Bell Telephone Laboratories
Country: United States

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.
LabVIEW G (pl, appeared 1986)
Also known as: g
Origin: National Instruments Corporation
Country: United States
Website: http://www.ni.com/labview


Laboratory Virtual Instrument Engineering Workbench (LabVIEW) is a system-design platform and development environment for a visual programming language from National Instruments. The graphical language is named "G"; not to be confused with G-code. Originally released for the Apple Macintosh in 1986, LabVIEW is commonly used for data acquisition, instrument control, and industrial automation on a variety of operating systems (OSs), including Microsoft Windows, various versions of Unix, Linux, and macOS. The latest versions of LabVIEW are LabVIEW 2017 and LabVIEW NXG 1.0, released in May 2017.
Ladder Logic (pl, appeared 1994)
Origin: International Electrotechnical Commission
Country: Switzerland


Ladder logic was originally a written method to document the design and construction of relay racks as used in manufacturing and process control. Each device in the relay rack would be represented by a symbol on the ladder diagram with connections between those devices shown. In addition, other items external to the relay rack such as pumps, heaters, and so forth would also be shown on the ladder diagram. See relay logic. Ladder logic has evolved into a programming language that represents a program by a graphical diagram based on the circuit diagrams of relay logic hardware. Ladder logic is used to develop software for programmable logic controllers (PLCs) used in industrial control applications. The name is based on the observation that programs in this language resemble ladders, with two vertical rails and a series of horizontal rungs between them. While ladder diagrams were once the only available notation for recording programmable controller programs, today other forms are standardized in IEC 61131-3 (For example, as an alternative to the graphical ladder logic form, there is also a more assembly language like format called Instruction list within the IEC 61131-3 standard.).
lain (pl, appeared 2017)
Origin: https://github.com/XXIIVV
Country: Unknown
Website: https://wiki.xxiivv.com/#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.



(add (sub 5 3) 2)                         ; Basic Math
(λ (a b c) (concat a b c))                ; Lambda
(def obj {:foo "bar"})                    ; Creating object
(join obj:foo)                            ; Reading object parameters
(def _sidebar (dom:create "sidebar"))     ; Creating DOM elements