From Esolang
Jump to navigation Jump to search
Paradigm(s) Procedural, Imperative
Designed by Elon Litman
Appeared in 2022
Memory system Cell-based
Dimensions One-dimensional
Computational class Turing complete
Major implementations Genesis Interpreter
Influenced by The Bible
File extension(s) .𐀁

Genesis 𐀁 is an interpreted, procedural, and Turing-complete diacriticless Paleo-Hebrew programming language.

Valid Keywords

Lexeme 𐀁 Equivalent(s)
Print π€„π€ƒπ€π€Ž
Print Line π€„π€ƒπ€π€Žπ€‡
Declare/Initialize Variable 𐀄𐀂𐀃𐀓
Declare Subroutine 𐀐𐀅𐀍𐀒𐀑𐀉𐀄
If π€€π€Œ
Then 𐀀𐀆
While 𐀁𐀏𐀅𐀃
For 𐀏𐀁𐀅𐀓
For Each π€π€π€…π€“π€Šπ€‹
Sleep 𐀉𐀔𐀍
Consecrate 𐀒-𐀃-𐀔

The `𐀒-𐀃-𐀔` keyword, meaning literally "to consecrate" or "to purify," denotes when the scope of a subroutine or loop terminates.

Operations, Punctuation Elements, & Identifiers

Java-style syntax and precedence are preserved for most operators:

`+` - addition (numbers, strings)
`-` - subtraction (numbers)
`/` - division (numbers)
`*` - multiplication (numbers)
`^` - power (numbers)
`=` - assignment (numbers, strings)
`==` - logical equals (numbers, strings)
`=!` - not equal to (numbers, strings)
`<` - less than (numbers)
`>` - greater than (numbers)
`=>` - greater than or equal to (numbers)
`=<` - less than or equal to (numbers)
`&&` - logical and (booleans)
`||` - logical or (booleans)

However, the associativity of most operators is from right-to-left:

𐀄𐀂𐀃𐀓 𐀐𐀅 = π€ŠΧ΄π€‡ - 𐀄׳ // 23

Identifiers can be represented by alphanumeric text (including `_`) and do not have to start with an alphabetic character.

  • Note*: To enable Paleo-Hebrew in the console, enable a TrueType font such as "Courier New."

Data Types & Literals

Genesis is weakly and dynamically typed, so casting between primitives is handled implicitly by the interpreter. There are three data types:

1. Number

  • Encompasses `Bytes`, `Shorts`, `Integers`, `Longs`, `Doubles`, and `Floats`.

2. Boolean

  • Supports literals `π€€π€Œπ€•` or `𐀔𐀒𐀓`, which correspond to `True` or `False`, respectively.

3. String

  • Delimited by quotation marks, e.g. `"!π€”π€‹π€…π€Œ π€π€…π€‹π€Œ"`.

The Paleo-Hebrew alphabet may have used gematria to denote cardinal values, although there is only evidence of this on the Samaria Ostraca and Dead Sea Scroll 4Q252. This quasi-decimal isopsephic number system is adopted for a lack of an academic consensus.

In this paradigm of numerology, there is no notation for zero, and the numeric values for individual letters are added together. Each unit (`1`, `2`, ..., `9`) is assigned a separate letter, each tens (`10`, `20`, ..., `90`) a separate letter, and the first four hundreds (`100`, `200`, `300`, `400`) a separate letter. The later hundreds (`500`, `600`, `700`, `800`, and `900`) are represented by the sum of two or three letters representing the first four hundreds. To represent numbers from `1,000` to `999,999`, the same letters are reused to serve as thousands, tens of thousands, and hundreds of thousands. Biblical pseudepigrapha use these transformations extensively. Standard (normative value) encoding per the conventional affine Mispar Hechrachi method of gematria is as follows:

Isopsephic values
Header text Header text Header text
Decimal Hebrew 𐀁 Glyph
1 Alep 𐀀
2 Bet 𐀁
3 Gimel 𐀂
4 Dalet 𐀃
5 He 𐀄
6 Waw 𐀅
7 Zayin 𐀆
8 Het 𐀇
9 Tet 𐀈
10 Yod 𐀉
20 Kaf 𐀊
30 Lamed 𐀋
40 Mem 𐀌
50 Nun 𐀍
60 Samek 𐀎
70 Ayin 𐀏
80 Pe 𐀐
90 Sade 𐀑
100 Qop 𐀒
200 Res 𐀓
300 Sin 𐀔
400 Taw 𐀕

Gershayim `Χ΄` (U+05F4 in Unicode, and resembling a double quote mark) (sometimes erroneously referred to as merkha'ot, which is Hebrew for double quote) are inserted before (to the right of) the last (leftmost) letter to indicate that the sequence of letters represents a gematric sequence of at least two Hebrew numerals (e.g., `28` β†’ `π€ŠΧ΄π€‡` and `5782` β†’ `𐀕𐀕𐀕𐀕𐀕𐀕𐀕𐀕𐀕𐀕𐀕𐀕𐀕𐀕𐀕𐀒𐀐״𐀁`).

Similarly, a single geresh `Χ³` (U+05F3 in Unicode, and resembling a single quote mark) is appended after (to the left of) a single letter in the case where a number is represented by a single Hebrew numeral (e.g. `100` β†’ `𐀒׳`).

Control Flow

The standard suite of loop constructs is supported. An iterative implementation for generating the first ten terms of the Fibonacci sequence using a `𐀁𐀏𐀅𐀃` loop is formulated as an example:

𐀄𐀂𐀃𐀓 π€Œπ€Žπ€π€“ = 𐀉׳
𐀄𐀂𐀃𐀓 𐀓𐀀𐀔𐀅𐀍 = 𐀀׳
𐀄𐀂𐀃𐀓 𐀔𐀍𐀉𐀄 = 𐀀׳ - 𐀀׳
𐀄𐀂𐀃𐀓 𐀃𐀋𐀐𐀒 = 𐀀׳ - 𐀀׳
𐀄𐀂𐀃𐀓 π€†π€Œπ€π€‰ = 𐀀׳ - 𐀀׳

𐀁𐀏𐀅𐀃 𐀃𐀋𐀐𐀒 <= π€Œπ€Žπ€π€“:
    π€„π€ƒπ€π€Žπ€‡ 𐀔𐀍𐀉𐀄
    π€†π€Œπ€π€‰ = 𐀓𐀀𐀔𐀅𐀍 + 𐀔𐀍𐀉𐀄
    𐀓𐀀𐀔𐀅𐀍 = 𐀔𐀍𐀉𐀄
    𐀔𐀍𐀉𐀄 = π€†π€Œπ€π€‰
    𐀃𐀋𐀐𐀒 = 𐀃𐀋𐀐𐀒 + 𐀀׳

The following `𐀏𐀁𐀅𐀓` loop prints out the first ten natural numbers:

𐀏𐀁𐀅𐀓 π€Œπ€Žπ€π€“=𐀉׳,π€Œπ€Žπ€π€“>=𐀀׳,π€Œπ€Žπ€π€“=π€Œπ€Žπ€π€“-𐀀׳:
    π€„π€ƒπ€π€Žπ€‡ π€Œπ€Žπ€π€“

To accomplish nested operations or anamorphism, it is recommended to do a composition of subroutines.


Functions in Genesis are declared using the `𐀐𐀅𐀍𐀒𐀑𐀉𐀄` keyword. Being void and non-parameterized, however, they are actually subroutines. There is recursion insomuch that making a self-referential call from within a subroutine is possible, but there is no means to exit that recursion to express the irrevocable danger of pride and egoism. This design follows the contention that recursion, as Peter Deutsch identified, is divine and not encompassed by the domain of human programmers, as evidenced by God identifying himself recursively. Genesis will never be object-oriented because the Bible explicitly forbids object worship. To call on a subroutine, use the reference name with which it was defined. The following subroutine `𐀇𐀉𐀁𐀅𐀓` approximates the gravitational force of a 290-gram KJV Compact Ultraslim Bible one meter from a 70-kg human being:

𐀄𐀂𐀃𐀓 π€Šπ€…π€‡ = (𐀀׳ / (𐀉׳ ^ 𐀉״𐀀)) * (π€•π€“π€ŽΧ΄π€† / 𐀒׳)
𐀄𐀂𐀃𐀓 𐀕𐀅𐀓𐀄 = 𐀊״𐀈 / 𐀒׳
𐀄𐀂𐀃𐀓 π€€π€ƒπ€Œ = 𐀏׳
𐀄𐀂𐀃𐀓 π€Œπ€“π€‡π€’ = 𐀀׳

𐀐𐀅𐀍𐀒𐀑𐀉𐀄 𐀇𐀉𐀁𐀅𐀓:
	 𐀄𐀂𐀃𐀓 𐀄𐀇𐀉𐀁𐀅𐀓 = (π€Šπ€…π€‡ * 𐀕𐀅𐀓𐀄 * π€€π€ƒπ€Œ) / (π€Œπ€“π€‡π€’ * π€Œπ€“π€‡π€’)
	 π€„π€ƒπ€π€Ž 𐀄𐀇𐀉𐀁𐀅𐀓


Other examples can be found in the respository.

Data Structures

Genesis provides fixed-length untyped array data structures. Curly braces are used to initialize arrays, and elements can be accessed or mutated through square bracket index operators:

𐀄𐀂𐀃𐀓 π€Œπ€Žπ€π€“ = {𐀀׳, 𐀁׳, 𐀂׳}

π€Œπ€Žπ€π€“[𐀈׳/𐀈׳] = 𐀔𐀒𐀓

π€π€π€…π€“π€Šπ€‹ π€€π€‹π€Œπ€π€ˆ, π€Œπ€Žπ€π€“:
	π€„π€ƒπ€π€Žπ€‡ π€€π€‹π€Œπ€π€ˆ

As denoted, `𐀏𐀁𐀅𐀓` or `π€π€π€…π€“π€Šπ€‹` looping an array will yield its values.

Math Library & Native Utilities

Function Description 𐀁 Equivalent(s)
Sqrt(#) Returns the correctly rounded positive square root of a number value. 𐀔𐀅𐀓𐀔(𐀍)
Sin(∠) Returns the trigonometric sine of an angle. π€Žπ€‰π€(𐀈)
Cos(∠) Returns the trigonometric cosine of an angle. π€’π€…π€Ž(𐀈)
Tan(∠) Returns the trigonometric tangent of an angle. 𐀈𐀍(𐀈)
ToDegrees(C) Converts an angle measured in radians to degrees. 𐀋𐀃(𐀒)
ToRadians(∠) Converts an angle measured in degrees to radians. 𐀋𐀓(𐀈)
Absolute(#) Returns the absolute value of a number value. 𐀏𐀂𐀋(𐀍)
Log(#) Returns the natural logarithm (base *e*) of a number value. (𐀍)𐀋𐀅𐀂
Exp(#) Returns Euler's number *e* raised to the power of a number value. (𐀍)π€€π€’π€Žπ€
Ulp(#) Returns the size of an ulp of the argument. (𐀍)𐀀𐀅𐀋𐀐
PI() Returns Ο€ rounded to double precision. ()𐀐𐀉𐀉
Random() Returns a number value greater than or equal to 0.0 and less than 1.0. ()𐀓𐀍𐀃

Some calculations:

𐀄𐀂𐀃𐀓 π€”π€ˆπ€‡ = 𐀃׳ * 𐀐𐀉𐀉() * (𐀉״𐀁 ^ 𐀁׳)
𐀄𐀂𐀃𐀓 π€Œπ€”π€…π€‹π€” = (𐀀׳/𐀁׳) * (𐀄׳ * π€ŽΧ΄π€ƒ * π€Žπ€‰π€(π€ŒΧ΄π€„))
𐀄𐀂𐀃𐀓 𐀒𐀋 = 𐀔𐀅𐀓𐀔(π€ŽΧ΄π€ƒ) * 𐀓𐀍𐀃()

π€„π€ƒπ€π€Žπ€‡ π€”π€ˆπ€‡
π€„π€ƒπ€π€Žπ€‡ π€Œπ€”π€…π€‹π€”
π€„π€ƒπ€π€Žπ€‡ 𐀒𐀋

External resources