R
- Ebuilds: 3, Stable: 4.5.0, Testing: 4.5.3 Description:
R is GNU S, a system for statistical computation and graphics. It
consists of a language plus a run-time environment with graphics, a
debugger, access to certain system functions, and the ability to run
programs stored in script files.
The core of R is an interpreted computer language which allows
branching and looping as well as modular programming using functions.
The R distribution contains functionality for a large number of
statistical procedures such as: linear and generalized linear
models, nonlinear regression models, time series analysis, classical
parametric and nonparametric tests, clustering, smoothing and
graphical data representations. Additional modules ("add-on
packages") are available for a variety of specific purposes but are
not distributed with this package.
Homepage:https://www.r-project.org/ License: || ( GPL-2 GPL-3 ) LGPL-2.1
algol68g
- Ebuilds: 4, Stable: 3.10.9, Testing: 3.11.0 Description:
Algol 68 Genie is free software distributed under the GNU General Public
License; it is a fast compiler-interpreter which ranks among the most
complete implementations of the language.
Homepage:https://jmvdveer.home.xs4all.nl/en.algol-68-genie.html License: GPL-3+
ammonite-repl-bin
- Ebuilds: 3, Stable: 3.0.0, Testing: 3.0.2 Description: Scala language-based scripting and REPL
Homepage:https://ammonite.io/ License: MIT
arc
- Ebuilds: 1, Testing: 3.2-r1 Description:
Arc is designed for exploratory programming: the kind where you
decide what to write by writing it. A good medium for exploratory
programming is one that makes programs brief and malleable,
so that's what we've aimed for. This is a medium for sketching
software.
Arc is unfinished. It's missing things you'd need to solve some
types of problems. But it works well for basic web apps.
Homepage:http://www.arclanguage.org/ License: Artistic-2
ats2
- Ebuilds: 1, Testing: 0.4.2-r1 Description:
ATS is a statically typed programming language that unifies implementation
with formal specification. It is equipped with a highly expressive type
system rooted in the framework Applied Type System, which gives the
language its name. In particular, both dependent types and linear types are
available in ATS. ATS2 extends ATS with an advanced template system,
allowing functional programming to be employed in a setting where only bare
minimal run-time support is available. In addition, the template system
makes ATS2 highly suitable for supporting numerical computation.
Homepage:https://www.cs.bu.edu/~hwxi/atslangweb/
https://sourceforge.net/projects/ats2-lang/ License: GPL-3+
bas
- Ebuilds: 1, Testing: 2.6-r2 Description:
Bas is an interpreter for the classic dialect of the programming
language BASIC. It is pretty compatible to typical BASIC interpreters of
the 1980s, unlike some other UNIX BASIC interpreters, that implement a
different syntax, breaking compatibility to existing programs. Bas
offers many ANSI BASIC statements for structured programming, such as
procedures, local variables and various loop types. Further there are
matrix operations, automatic LIST indentation and many statements and
functions found in specific classic dialects. Line numbers are not
required. Bas is written in ANSI C for UNIX systems.
Homepage:http://www.moria.de/~michael/bas/ License: MIT
boogie
- Ebuilds: 1, Stable: 3.5.6 Description:
Boogie is an intermediate verification language (IVL), intended as a layer
on which to build program verifiers for other languages. Several program
verifiers have been built in this way, including the VCC and HAVOC
verifiers for C and the verifiers for Dafny, Chalice, and Spec#. For a
sample verifier for a toy language built on top of Boogie, see Forro.
Boogie is also the name of a tool. The tool accepts the Boogie language as
input, optionally infers some invariants in the given Boogie program, and
then generates verification conditions that are passed to an SMT solver.
The default SMT solver is Z3.
Homepage:https://github.com/boogie-org/boogie/ License: MIT
c-intercal
- Ebuilds: 1, Testing: 33.0-r2 Description:
An implementation of the language INTERCAL, legendary for its perversity
and horribleness (this version adds COME FROM for extra flavor). Comes with
language manual and examples including possibly the entire extant body of
INTERCAL code. Now supports i18n and l14n (to Ancient Roman locale only).
Now with fix patch by Donald Knuth.
Homepage:http://www.catb.org/~esr/intercal/
https://gitlab.com/esr/intercal License: GPL-2+ FDL-1.2+
cfortran
- Ebuilds: 2, Stable: 20210827, Testing: 20210827-r1 Description:
cfortran is a header file to ease bridge between C and FORTRAN. It
provides an interface between C and FORTRAN routines and global
data, i.e. structures and COMMON blocks. This package includes
patches from Debian for better support on newer compilers and architectures.
Homepage:https://www-zeus.desy.de/~burow/cfortran/ https://github.com/bastien-roucaries/cfortran License: LGPL-2
clips
- Ebuilds: 1, Stable: 6.40-r1, Testing: 6.40-r1 Description:
This package is a pure C implementation of CLIPS.
CLIPS is a forward-chaining rule-based programming language written in C
that also provides procedural and object-oriented programming facilities.
Homepage:http://www.clipsrules.net/ License: public-domain
clipsjni
- Ebuilds: 1, Stable: 6.40-r1, Testing: 6.40-r1 Description:
This package is a Java implementation of CLIPS with
a native shared library and a IDE.
CLIPS is a forward-chaining rule-based programming language written in C
that also provides procedural and object-oriented programming facilities.
Homepage:http://www.clipsrules.net/ License: public-domain
cll1h
- Ebuilds: 1, Testing: 0.6-r1 Description: C<<1 programming language system
Homepage:http://gpl.arachne.cz/ License: LGPL-2.1
closure-compiler-bin
- Ebuilds: 4, Stable: 20260121, Testing: 20260304 Description:
The Closure Compiler is a tool for making JavaScript download and run
faster. It is a true compiler for JavaScript. Instead of compiling from a
source language to machine code, it compiles from JavaScript to better
JavaScript. It parses your JavaScript, analyzes it, removes dead code and
rewrites and minimizes what's left. It also checks syntax, variable
references, and types, and warns about common JavaScript pitfalls.
Homepage:https://developers.google.com/closure/compiler/
https://github.com/google/closure-compiler/ License: Apache-2.0
coffee-script
- Ebuilds: 1, Stable: 2.7.0 Description:
CoffeeScript is a little language that compiles into JavaScript. Underneath
that awkward Java-esque patina, JavaScript has always had a gorgeous heart.
CoffeeScript is an attempt to expose the good parts of JavaScript in a
simple way. The golden rule of CoffeeScript is: "It's just JavaScript." The
code compiles one-to-one into the equivalent JS, and there is no
interpretation at runtime. You can use any existing JavaScript library
seamlessly from CoffeeScript (and vice-versa). The compiled output is
readable, pretty-printed, and tends to run as fast or faster than the
equivalent handwritten JavaScript.
Homepage:https://coffeescript.org/ License: MIT
crystal
- Ebuilds: 2, Stable: 1.19.1 Description:
Crystal is a programming language that resembles Ruby but compiles to
native code and tries to be much more efficient, at the cost of disallowing
certain dynamic aspects of Ruby.
Homepage:https://crystal-lang.org/
https://github.com/crystal-lang/crystal/ License: Apache-2.0
cue
- Ebuilds: 1, Testing: 0.14.1 Description: open-source data validation language and inference engine
Homepage:https://cuelang.org License: Apache-2.0
dafny
- Ebuilds: 1, Stable: 4.11.0 Description:
Dafny is a verification-ready programming language. As you type in your
program, Dafny's verifier constantly looks over your shoulder, flags any
errors, shows you counterexamples, and congratulates you when your code
matches your specifications. When you're done, Dafny can compile your code
to C#, Java, JavaScript or Go (more to come!), so it can integrate with
your existing workflow. Dafny will give you assurance that your code meets
the specifications you write, while letting you write both code and
specifications in the Dafny programming language itself. Since verification
is an integral part of development, it will thus reduce the risk of costly
late-stage bugs that are typically missed by testing. Dafny has support for
common programming concepts such as classes and trait inheritance,
inductive datatypes that can have methods and are suitable for pattern
matching, lazily unbounded datatypes, subset types e.g. for bounded
integers, lambdas, and immutable and mutable data structures. Dafny also
offers an extensive toolbox for mathematical proofs, such as unbounded and
bounded quantifiers, calculational proofs, pre- and post-conditions,
termination conditions, loop invariants, and read/write specifications.
Homepage:https://dafny.org/
https://github.com/dafny-lang/dafny/ License: Apache-2.0 BSD-2 MIT
dafny-bin
- Ebuilds: 1, Stable: 4.11.0-r1 Description:
Dafny is a verification-ready programming language. As you type in your
program, Dafny's verifier constantly looks over your shoulder, flags any
errors, shows you counterexamples, and congratulates you when your code
matches your specifications. When you're done, Dafny can compile your code
to C#, Java, JavaScript or Go (more to come!), so it can integrate with
your existing workflow. Dafny will give you assurance that your code meets
the specifications you write, while letting you write both code and
specifications in the Dafny programming language itself. Since verification
is an integral part of development, it will thus reduce the risk of costly
late-stage bugs that are typically missed by testing. Dafny has support for
common programming concepts such as classes and trait inheritance,
inductive datatypes that can have methods and are suitable for pattern
matching, lazily unbounded datatypes, subset types e.g. for bounded
integers, lambdas, and immutable and mutable data structures. Dafny also
offers an extensive toolbox for mathematical proofs, such as unbounded and
bounded quantifiers, calculational proofs, pre- and post-conditions,
termination conditions, loop invariants, and read/write specifications.
Homepage:https://dafny.org/
https://github.com/dafny-lang/dafny/ License: MIT
deno-bin
- Ebuilds: 3, Stable: 2.6.10-r1, Testing: 2.7.9 Description: Modern runtime for JavaScript and TypeScript
Homepage:https://deno.com/ License: MIT
Apache-2.0 Apache-2.0-with-LLVM-exceptions BSD-2 BSD CC0-1.0 ISC MIT
MPL-2.0 openssl Unicode-3.0 Unicode-DFS-2016 ZLIB
dzaima-bqn
- Ebuilds: 3, Stable: 0.2.1, Testing: 9999 Description: A BQN language implementation written in Java, also know as dbqn
Homepage:https://github.com/dzaima/BQN/
eisl
- Ebuilds: 1, Stable: 5.62, Testing: 5.62 Description:
Easy-ISLisp(EISL) is an interpreter and compiler compatible with the ISLisp
standard. EISL was written by Kenichi Sasagawa
https://qiita.com/sym_num/items/793adfe118514668e5b0
Homepage:https://github.com/sasagawa888/eisl/
elpi
- Ebuilds: 2, Testing: 2.0.7 Description:
ELPI implements a variant of λProlog enriched with Constraint Handling
Rules, a programming language well suited to manipulate syntax trees with
binders. ELPI is designed to be embedded into larger applications written
in OCaml as an extension language. It comes with an API to drive the
interpreter and with an FFI for defining built-in predicates and data
types, as well as quotations and similar goodies that are handy to adapt
the language to the host application.
Homepage:https://github.com/LPCIC/elpi/
erlang
- Ebuilds: 7, Stable: 28.3, Testing: 28.3.1 Description:
Erlang is a programming language designed at the Ericsson
Computer Science Laboratory. Open-source Erlang is being
released to help encourage the spread of Erlang outside
Ericsson.
Homepage:https://www.erlang.org/ https://github.com/erlang/otp License: Apache-2.0
esco
- Ebuilds: 1, Testing: 0.513 Description: Combine interpreter of esoteric languages
Homepage:https://esco.sourceforge.net/ License: GPL-2+
execline
- Ebuilds: 3, Stable: 2.9.7.0, Testing: 2.9.8.1 Description:
Execline is a non-interactive scripting language similar to sh.
According to the home page, the syntax is far mor logical and
predictable than sh, and has no security issues.
Homepage:https://www.skarnet.org/software/execline/ License: ISC
f2c
- Ebuilds: 1, Stable: 20240312 Description:
F2C compiles FORTRAN 77 sources by converting to C/C++ sources and
compiling the later with gcc. The resulting binaries depend on the
libf2c runtime library.
Homepage:https://www.netlib.org/f2c License: HPND
fennel
- Ebuilds: 4, Stable: 1.4.2-r1, Testing: 1.6.1 Description:
Fennel is a lisp that compiles to Lua. It aims to be easy to use,
expressive, and has almost zero overhead compared to handwritten Lua.
Full Lua compatibility - You can use any function or library from Lua.
Zero overhead - Compiled code should be just as or more efficient
than hand-written Lua.
Compile-time macros - Ship compiled code with no runtime dependency
on Fennel.
Embeddable - Fennel is a one-file library as well as an executable.
Embed it in other programs to support runtime extensibility and
interactive development.
At https://fennel-lang.org there's a live in-browser REPL you can use
without installing anything.
Homepage:https://fennel-lang.org/
https://sr.ht/~technomancy/fennel/
gdl
- Ebuilds: 1, Testing: 1.0.4-r2 Description:
A free IDL (Interactive Data Language) compatible incremental compiler
(ie. runs IDL programs). IDL is a registered trademark of ITT Visual
Information Solutions.
Homepage:https://github.com/gnudatalanguage/gdl License: GPL-2
gforth
- Ebuilds: 1, Testing: 0.7.3-r2 Description: GNU Forth is a fast and portable implementation of the ANSI Forth language
Homepage:https://www.gnu.org/software/gforth License: GPL-3
go
- Ebuilds: 7, Stable: 1.25.8, 1.25.5-r1, Testing: 1.26.1 Description:
Go is a new systems programming language developed at google by
Rob Pike. It has garbage collection, coroutines, communication
channels and a clean syntax.
Homepage:https://go.dev License: BSD
go-bootstrap
- Ebuilds: 3, Stable: 1.22.12, Testing: 1.24.6 Description:
This package is used only to boot strap <pkg>dev-lang/go</pkg>.
It is not meant to be used by end users directly.
Homepage:https://golang.org License: BSD
grass
- Ebuilds: 1, Stable: 0.13.4 Description: A Sass compiler written purely in Rust
Homepage:https://github.com/connorskees/grass License: MIT MIT Unicode-DFS-2016
haxe
- Ebuilds: 1, Testing: 4.3.6-r4 Description:
Haxe is an open source toolkit based on a modern, high level, static-typed
programming language, a cross-compiler, a complete cross-platform standard
library and ways to access each platform's native capabilities.
Homepage:https://haxe.org/
https://github.com/HaxeFoundation/haxe/
icon
- Ebuilds: 3, Stable: 9.5.24b-r1, Testing: 9.5.24b-r1 Description: Very high level language
Homepage:https://www.cs.arizona.edu/icon/ License: public-domain HPND
idris2
- Ebuilds: 1, Testing: 0.7.0-r2 Description:
Idris is a programming language designed to encourage Type-Driven
Development.
In type-driven development, types are tools for constructing programs.
We treat the type as the plan for a program, and use the compiler
and type checker as our assistant, guiding us to a complete program that
satisfies the type. The more expressive the type is that we give up front,
the more confidence we can have that the resulting program will be correct.
Homepage:https://idris-lang.org/
inform
- Ebuilds: 3, Stable: 6.42_p4, Testing: 6.42_p4 Description: Design system for interactive fiction
Homepage:https://www.inform-fiction.org/ License: Artistic-2 Inform
janet
- Ebuilds: 1, Testing: 1.32.1 Description:
Janet is a functional and imperative programming language and bytecode
interpreter. It is a modern lisp, but lists are replaced by other data
structures with better utility and performance
(arrays, tables, structs, tuples).
The language also supports bridging to native code written in C,
meta-programming with macros, and bytecode assembly.
Homepage:https://janet-lang.org https://github.com/janet-lang/janet/ License: MIT
jimtcl
- Ebuilds: 3, Stable: 0.82, Testing: 0.82 Description: Small footprint implementation of Tcl programming language
Homepage:https://jim.tcl.tk/ License: LGPL-2
jint
- Ebuilds: 2, Stable: 3.1.2, Testing: 4.5.0 Description:
Jint is a Javascript interpreter for .NET which can run on any modern .NET
platform as it supports .NET Standard 2.0 and later.
Homepage:https://github.com/sebastienros/jint/ License: Apache-2.0 BSD-2 BSD MIT
jsonnet
- Ebuilds: 2, Stable: 0.21.0, Testing: 0.22.0 Description: A data templating language for app and tool developers
Homepage:https://jsonnet.org/ License: Apache-2.0
julia-bin
- Ebuilds: 8, Testing: 9999 Description:
Julia is a high-level, high-performance dynamic programming language for
technical computing, with syntax that is familiar to users of other
technical computing environments. It provides a sophisticated
compiler, distributed parallel execution, numerical accuracy, and an
extensive mathematical function library. The library, mostly written
in Julia itself, also integrates mature, best-of-breed C and Fortran
libraries for linear algebra, random number generation, FFTs, and
string processing. Julia programs are organized around defining
functions, and overloading them for different combinations of
argument types (which can also be user-defined).
Homepage:https://julialang.org/
kotlin-bin
- Ebuilds: 2, Testing: 2.3.20 Description:
Kotlin is a statically typed language that targets the JVM and JavaScript.
It is a general-purpose language intended for industry use. It is developed
by a team at JetBrains although it is an OSS language and has external
contributors.
Homepage:https://kotlinlang.org/
https://github.com/JetBrains/kotlin/ License: Apache-2.0 BSD MIT NPL-1.1
lfe
- Ebuilds: 1, Testing: 2.2.0-r1 Description:
LFE, Lisp Flavoured Erlang, is a lisp syntax front-end
to the Erlang compiler. Code produced with it is compatible
with "normal" Erlang code.
An LFE evaluator and shell is also included.
Homepage:https://lfe.io/
https://github.com/rvirding/lfe/
logtalk
- Ebuilds: 1, Stable: 3.47.0-r2 Description: Open source object-oriented logic programming language
Homepage:https://logtalk.org License: Apache-2.0
lua
- Ebuilds: 4, Stable: 5.4.8, Testing: 5.4.8 Description: A powerful light-weight programming language designed for extending applications
Homepage:https://www.lua.org/ License: MIT
luajit
- Ebuilds: 4, Stable: 2.1.1731601260, Testing: 2.1.9999999999 Description: Just-In-Time Compiler for the Lua programming language
Homepage:https://luajit.org/
luau
- Ebuilds: 2, Stable: 0.669, Testing: 0.707 Description:
Luau is a fast, small, safe, gradually typed embeddable scripting language
derived from Lua. It is designed to be backwards compatible with Lua 5.1,
as well as incorporating some features from future Lua releases, but also
expands the feature set (most notably with type annotations). Luau is
largely implemented from scratch, with the language runtime being a very
heavily modified version of Lua 5.1 runtime, with completely rewritten
interpreter and other performance innovations. The runtime mostly preserves
Lua 5.1 API, so existing bindings should be more or less compatible with a
few caveats.
Homepage:https://luau.org/
https://github.com/luau-lang/luau/
maude
- Ebuilds: 5, Testing: 3.5.1 Description:
Maude is a high-performance reflective language and system supporting
both equational and rewriting logic specification and programming for a
wide range of applications. Maude has been influenced in important ways
by the OBJ3 language, which can be regarded as an equational logic
sublanguage. Besides supporting equational specification and
programming, Maude also supports rewriting logic computation.
Homepage:https://maude.cs.uiuc.edu/ License: GPL-2
mercury
- Ebuilds: 1, Stable: 22.01.1-r1 Description: Mercury is a modern general-purpose logic/functional programming language
Homepage:https://mercurylang.org License: GPL-2 LGPL-2
mercury-extras
- Ebuilds: 1, Stable: 22.01.1 Description: Additional libraries and tools that are not part of the Mercury standard library
Homepage:https://www.mercurylang.org/index.html License: GPL-2 LGPL-2
micropython
- Ebuilds: 2, Testing: 1.25.0 Description:
The MicroPython project aims to put an implementation of Python 3.x on
microcontrollers and small embedded systems.
MicroPython implements the entire Python 3.4 syntax (including exceptions,
with, yield from, etc., and additionally async/await keywords from Python 3.5).
The following core datatypes are provided: str (including basic Unicode
support), bytes, bytearray, tuple, list, dict, set, frozenset, array.array,
collections.namedtuple, classes and instances. Builtin modules include sys,
time, and struct, etc. Select ports have support for _thread module
(multithreading). Note that only a subset of Python 3 functionality is
implemented for the data types and modules.
MicroPython can execute scripts in textual source form or from precompiled
bytecode, in both cases either from an on-device filesystem or "frozen" into
the MicroPython executable.
Homepage:https://micropython.org https://github.com/micropython/micropython License: Apache-2.0 BSD BSD-1 BSD-4 GPL-2 GPL-2+ ISC LGPL-3 MIT OFL-1.1 ZLIB
mlton
- Ebuilds: 1, Testing: 20180207 Description: Standard ML optimizing compiler and libraries
Homepage:http://www.mlton.org License: HPND MIT
mono
- Ebuilds: 2, Stable: 6.14.1, 6.12.0.199-r2, Testing: 6.14.1 Description: Mono open source ECMA CLI, C# and .NET implementation
Homepage:https://gitlab.winehq.org/mono/mono License: MIT LGPL-2.1 GPL-2 BSD-4 NPL-1.1 Ms-PL GPL-2-with-linking-exception IDPL
mono-basic
- Ebuilds: 1, Stable: 4.8-r1 Description:
This package contains the visual basic runtime and compiler,
which are used by the mono project, to make
Visual Basic .NET projects run under linux.
Current compatibility level is Visual Basic 8 / .NET 2.0.
Homepage:https://www.mono-project.com/docs/about-mono/languages/visualbasic/ License: LGPL-2 MIT
mrustc
- Ebuilds: 3, Stable: 0.11.2-r1, Testing: 9999 Description:
A "simple" rust compiler written in C++ that is able to bootstrap a "recent" rustc.
Homepage:https://github.com/thepowersgang/mrustc
mujs
- Ebuilds: 3, Stable: 1.3.6, Testing: 1.3.8 Description:
MuJS is a lightweight Javascript interpreter designed for embedding in
other software to extend them with scripting capabilities.
Homepage:https://mujs.com/ https://github.com/ccxvii/mujs License: ISC
nasm
- Ebuilds: 2, Stable: 3.01, Testing: 3.01 Description:
The Netwide Assembler, NASM, is an 80x86 assembler designed for portability
and modularity. It supports a range of object file formats, including Linux
and NetBSD/FreeBSD a.out, ELF, COFF, Microsoft 16-bit OBJ and Win32. It
will also output plain binary files. Its syntax is designed to be simple
and easy to understand, similar to Intel's but less complex. It supports
Pentium, P6, MMX, 3DNow!, SSE and SSE2 opcodes, and has macro capability.
Homepage:https://www.nasm.us/ License: BSD-2
neko
- Ebuilds: 2, Testing: 2.4.1 Description:
Neko is a high-level dynamically typed programming language. It can be
used as an embedded scripting language. It has been designed to provide
a common runtime for several different languages. Learning and using
Neko is very easy. You can easily extend the language with C libraries.
You can also write generators from your own language to Neko and then
use the Neko Runtime to compile, run, and access existing libraries.
Homepage:https://nekovm.org/
https://github.com/HaxeFoundation/neko/
nelua
- Ebuilds: 2, Testing: 99999999 Description:
Nelua (stands for Native Extensible Lua) is a minimal, efficient,
statically-typed and meta-programmable systems programming language heavily
inspired by Lua, which compiles to C and native code.
Homepage:https://nelua.io/
https://github.com/edubart/nelua-lang/
nim
- Ebuilds: 2, Stable: 2.2.6, Testing: 2.2.8 Description:
Nim is a statically typed compiled systems programming language.
It combines successful concepts from mature languages like Python,
Ada and Modula.
Nim generates native dependency-free executables, not dependent on a
virtual machine, which are small and allow easy redistribution.
The Nim compiler and the generated executables support all major platforms
like Windows, Linux, BSD and macOS.
Nim's memory management is deterministic and customizable with destructors
and move semantics, inspired by C++ and Rust. It is well-suited for
embedded, hard-realtime systems.
Modern concepts like zero-overhead iterators and compile-time evaluation of
user-defined functions, in combination with the preference of value-based
datatypes allocated on the stack, lead to extremely performant code.
Support for various backends: it compiles to C, C++ or JavaScript so that
Nim can be used for all backend and frontend needs.
Nim is self-contained: the compiler and the standard library are
implemented in Nim.
Nim has a powerful macro system which allows direct manipulation of the
AST, offering nearly unlimited opportunities.
Macros cannot change Nim's syntax because there is no need for it — the
syntax is flexible enough.
Modern type system with local type inference, tuples, generics and sum
types.
Statements are grouped by indentation but can span multiple lines.
Homepage:https://nim-lang.org/
https://github.com/nim-lang/Nim/ License: MIT
nprolog
- Ebuilds: 5, Stable: 4.79, Testing: 4.84 Description:
N-Prolog(NPL) is an interpreter and compiler to be compatible with
Arity/Prolog32. N-Prolog is NOT ISO-Prolog. About Arity/prolog32 see
http://petergabel.info/ArityProlog32/ArityProlog32PredList/
Homepage:https://github.com/sasagawa888/nprolog/
oorexx
- Ebuilds: 1, Stable: 5.1.0_beta12932, Testing: 5.1.0_beta12932 Description:
Open Object Rexx (ooRexx) is an Open Source project managed by Rexx
Language Association (RexxLA) providing a free implementation of Object
Rexx. ooRexx is distributed under Common Public License (CPL) v1.0. Object
Rexx is an enhancement of classic Rexx; a powerful, full-featured
programming language which has a human-oriented syntax.
Homepage:https://www.oorexx.org/
https://sourceforge.net/projects/oorexx/ License: CPL-1.0
parrot
- Ebuilds: 1, Testing: 8.1.0-r4 Description: Virtual machine designed to compile and execute bytecode for dynamic languages
Homepage:http://www.parrot.org/ License: Artistic-2
pico8
- Ebuilds: 2, Testing: 0.2.7 Description:
PICO-8 is a fantasy console for making, sharing and playing tiny games
and other computer programs. When you turn it on, the machine greets you
with a shell for typing in Lua programs and provides simple built-in
tools for creating sprites, maps and sound.
The harsh limitations of PICO-8 are carefully chosen to be fun to work
with, encourage small but expressive designs and hopefully to give
PICO-8 cartridges their own particular look and feel.
Homepage:https://www.lexaloffle.com/pico-8.php License: PICO-8 MIT BSD-2
pypy
- Ebuilds: 4, Stable: 3.11.7.3.20_p2, Testing: 3.11.7.3.21 Description: A fast, compliant alternative implementation of the Python ($(ver_cut) language
Homepage:
https://pypy.org/
https://github.com/pypy/pypy/
License: MIT
qore
- Ebuilds: 1, Stable: 1.19.2, Testing: 1.19.2 Description:
The Qore programming language is a powerful, thread-capable, embeddable
weakly-typed language with optional strong typing and procedural and
object-oriented features designed for anything from quick scripting to
complex multithreaded, network-aware application development to embedded
application scripting. Qore was initially designed to facilitate the rapid
implementation of sophisticated interfaces in embedded code in an
enterprise environment, and has since grown into a general-purpose language
as well.
Homepage:http://qore.org/
https://github.com/qorelanguage/qore/
regina-rexx
- Ebuilds: 2, Stable: 3.9.6 Description:
Regina is a Rexx interpreter. Rexx is a programming language that was
designed to be easy to use for inexperienced programmers yet powerful
enough for experienced users. It is also a language ideally suited as a
macro language for other applications.
Homepage:https://regina-rexx.sourceforge.io/ License: LGPL-2.1 MPL-1.0
ruby
- Ebuilds: 9, Stable: 3.3.10-r1, Testing: 4.0.1 Description: An object-oriented scripting language
Homepage:https://www.ruby-lang.org/ License: || ( Ruby-BSD BSD-2 )
rust-bin
- Ebuilds: 26, Stable: 1.92.0, Testing: 9999 Description: Systems programming language from Mozilla
Homepage:https://www.rust-lang.org/
rust-common
- Ebuilds: 17, Stable: 1.92.0, Testing: 9999 Description: Common files shared between multiple slots of Rust
Homepage:https://www.rust-lang.org/
sassc
- Ebuilds: 1, Stable: 3.6.2, Testing: 3.6.2 Description:
SassC is a wrapper around libsass (http://github.com/sass/libsass)
used to generate a useful command-line application that can be
installed and packaged for several operating systems.
Homepage:https://github.com/sass/sassc License: MIT
scala-bin
- Ebuilds: 1, Stable: 2.13.9-r1 Description: The Scala Programming Language
Homepage:https://scala.epfl.ch/ License: Apache-2.0
scrapscript
- Ebuilds: 2, Testing: 9999 Description:
Scrapscript solves the software sharability problem. Modern software
breaks at boundaries. APIs diverge, packages crumble, configs ossify,
serialization corrupts, git tangles, dependencies break, documentation
dies, vulnerabilities surface, etc. To make software safe and sharable,
scrapscript combines existing wisdom in new ways: all expressions are
content-addressible "scraps", all programs are data, all programs are
"platformed".
Homepage:https://scrapscript.org/
https://github.com/tekknolagi/scrapscript/
smlnj
- Ebuilds: 2, Testing: 110.99.9 Description:
Standard ML of New Jersey (abbreviated SML/NJ) is a compiler for
the Standard ML '97 programming language with associated libraries,
tools, and documentation. SML/NJ is free, open source software.
Homepage:http://www.smlnj.org License: BSD
snobol
- Ebuilds: 1, Testing: 1.4.1-r1 Description: Phil Budne's port of Macro SNOBOL4 in C, for modern machines
Homepage:http://www.snobol4.org/csnobol4/ License: BSD-2
spark
- Ebuilds: 1, Testing: 2024.01.11-r2 Description:
SPARK is a software development technology specifically designed for
engineering high-reliability applications. It consists of a programming
language, a verification toolset and a design method which, taken
together, ensure that ultra-low defect software can be deployed in
application domains where high-reliability must be assured, for example
where safety and security are key requirements.
Homepage:http://libre.adacore.com License: GPL-3
squirrel
- Ebuilds: 1, Stable: 3.2 Description: A interpreted language mainly used for games
Homepage:http://squirrel-lang.org/ License: ZLIB
swi-prolog
- Ebuilds: 3, Stable: 10.0.0-r1, Testing: 10.0.2 Description:
SWI-Prolog is a versatile implementation of the Prolog
language. Although SWI-Prolog gained its popularity primarily in education,
its development is mostly driven by the needs for application
development. This is facilitated by a rich interface to other IT components
by supporting many document types and (network) protocols as well as a
comprehensive low-level interface to C that is the basis for high-level
interfaces to C++, Java (bundled) and other externally available.
Homepage:https://www.swi-prolog.org/
https://github.com/SWI-Prolog/swipl-devel/
swig
- Ebuilds: 3, Stable: 4.2.1, Testing: 4.3.1 Description:
SWIG is a software development tool that connects programs written in C and C++
with a variety of high-level programming languages. SWIG is used with different
types of languages including common scripting languages such as Perl, Python,
Tcl/Tk and Ruby. The list of supported languages also includes non-scripting
languages such as C#, Common Lisp (Allegro CL), Java, Modula-3 and OCAML. Also
several interpreted and compiled Scheme implementations (Chicken, Guile,
MzScheme) are supported.
Homepage:http://www.swig.org/ https://github.com/swig/swig License: GPL-3+ BSD BSD-2
teyjus
- Ebuilds: 1, Testing: 2.1-r2 Description:
The Teyjus system is an efficient implementation of the higher-order
logic programming language Lambda Prolog. The main strength of Lambda
Prolog, a language developed by Dale Miller and Gopalan Nadathur, is
the support it offers for what is known as lambda tree syntax, a new
and effective way to view the structure of complex syntactic objects
such as types, formulas, proofs and programs. Lambda Prolog provides
this support by using lambda terms as data representation devices and
by including primitives for probing such terms in logically meaningful
ways. The new features present in the language raise several
implementation challenges that have been addressed in collaborative
work between Nadathur and his students and colleagues. The name
"Teyjus" actually stands both for a project and for a class of
compiler and virtual machine based realizations of Lambda Prolog
arising from the research carried out within this project. Underlying
the most recent version of the Teyjus system is a new and
significantly improved virtual machine that has been designed by
Xiaochu Qi as part of her doctoral dissertation work at the University
of Minnesota. This virtual machine extensively exploits a special form
of higher-order unification known as pattern unification.
Homepage:https://teyjus.cs.umn.edu/ License: GPL-3
tuprolog
- Ebuilds: 1, Stable: 3.2.0-r3 Description: tuProlog is a light-weight Prolog for Internet applications and infrastructures
Homepage:http://tuprolog.unibo.it/ License: LGPL-3 BSD
typescript
- Ebuilds: 1, Stable: 5.9.3, Testing: 5.9.3 Description:
TypeScript is a language for application-scale JavaScript. TypeScript adds
optional types to JavaScript that support tools for large-scale JavaScript
applications for any browser, for any host, on any OS. TypeScript compiles
to readable, standards-based JavaScript
Homepage:https://www.typescriptlang.org/
https://github.com/microsoft/TypeScript/ License: Apache-2.0
xsb
- Ebuilds: 1, Stable: 4.0.0-r4 Description: XSB is a logic programming and deductive database system
Homepage:https://xsb.sourceforge.net License: GPL-2 LGPL-2