ᚱᚢᚾᛅᛦ

From Esolang
Jump to: navigation, search

ᚱᚢᚾᛅᛦ (Rúnaʀ) is a Runic fungeoid currently being developed by User:Salpynx after noticing that there were no existing esolangs written in runic (other than Юᓂ곧⎔ which incorporates them for pre-processor directives). It is based on RunR, which looked like a close match as a near/false declension of the Old Norse word for rune: rún. If rún were a masculine root, Rúnʀ would be masc. s. 'rune'. Rún is in fact feminine, so Rúnaʀ is the correct feminine plural: 'runes'.

Deviations from RunR have been made to accommodate example historical code-rune inscriptions which should be valid code and produce interesting results in ᚱᚢᚾᛅᛦ. Where RunR is unclear, or further clarification of mechanics are required, Befunge, the very well documented proto-fungeoid, has been used as a guide. Orthagonal and Orthogonal were also examined, as RunR may be derived from them. Some of its characteristics seem closer to those than Befunge, although I do not know the history or intentions of RunR.

Description

ᚱᚢᚾᛅᛦ makes use of Younger Futhark short-twig runes (all of them), topped up with some Elder Futhark runes to represent less used functions.

The author feels that obscure and obfuscated languages which are awkward to write but provide convenient ASCII and numeric outputs are lazy and inelegant. ᚱᚢᚾᛅᛦ stays true to its theme by only supporting character output in runes, which should be sufficient for all data output and communication.

Values in RunR are arbitrarily capped at 255, but we do not need the extra, junk characters. There are 16 runes in the Younger Futhark sequence, these are representable by 4-bit nybbles, 0x0-0xF. 0x0 represents the first rune Fehu, with value 1. 0xF is Yr, and has the value of 16. An actual 0 for arithmetic purposes is achieved by using an unassigned cell, None/Null, as an operand.

Output therefore is any of the 16 Younger Futhark runes, potentially separated by Null bytes. This allows human readable output in Old Norse. There is no option for distinguishing between character and numeric output, which is in keeping with runes which could be used to equally represent words and numbers, depending on context. Arbitrary digital data output is provided if the runes are taken in pairs, to represent hex bytes. Any modern data encoding can be represented in this way. Interpreters may choose to provide a convenience output option to convert the runes to raw data, but this is not a provision or requirement of the language. Runes are sufficient.

Pentimal representation

In code, the runes themselves are interpreted as commands. To set a cell value, the pentimal numbering system is used. Unicode does not provide representation for these, so the numbers are formed by using combining diacritics on a base Isa rune stave, U+16C1.

Aettir 3
value 1 2 3 4 5 6
rune
pentimal ᛁ̵ ᛁ̿ ᛁ̵̿ ᛁ̳̿ ᛁ͗ ᛁ̵͗
Aettir 2
value 7 8 9 10 11
rune
pentimal ᛁ͗̿ ᛁ̵͗̿ ᛁ̳͗̿ ᛁ̊ ᛁ̵̊
Aettir 1
value 12 13 14 15 16
rune
pentimal ᛁ̊̿ ᛁ̵̊̿ ᛁ̳̊̿ ᛁ̹̊ ᛁ̵̹̊

Commands

Instruction Name Description
sól (sun) The start of the program. Different forms denote different start directions and wrapping behaviour
yr (yew) The end of the program
bjarkan (birch) Input request, reads a value from the user and stores it in the current pointer variable
óss (god = Odin) Output, writes out the current pointer variable as a rune
maðr (man) Push current pointer variable into the stack
hagall (hail) Pop value from the stack and store it in the current pointer variable
odal (possession) Arithmetic, pop stack and add current pointer variable, store result in pointer variable
gebo (gift) Arithmetic, pop stack and subtract current pointer variable, store result in pointer variable
féhu (wealth) Arithmetic, pop stack and multiply by current pointer variable, store result in pointer variable
kaunan (ulcer) Arithmetic, pop stack and divide by current pointer variable, store result in pointer variable
ᛁ̵ to ᛁ̵̹̊ Pentimal predefinitions, sets the current pointer variable to the given value 1-16. See ᚱᚢᚾᛅᛦ#Pentimal_representation
maðr (man), Elder form Branch, current pointer branches stack
hagall (hail), Elder form Prune, prune current stack branch
and reið (ride) and úr (iron/slag) (n.b. staveless forms) Focusers, the unconditionally redirect movement to the direction that they are pointing
and Týr and lögr Reflectors
and single punctuation (horizontal wall), and ísa (ice) (vertical wall)) Ice walls, when hit from the side no reflection occurs
cross punctuation A multidirectional wall, causes a reflection from any direction
Thurs (giant) A conditional gate, when the pointer value is falsey, reflection occurs (giant guards the gate, must have runes to pass)
ihaz (yew) A negatory operator, performs not on the current pointer variable truthiness
wunjō (joy) Clear current pointer variable: set to None ( 0 / Falsey)
ehwaz (horse) A conditional jump, when the current pointer variable value is truthy, the next instruction is skipped
nauðr (need) A left turntable, it rotates movement left by 90 degrees, 'left' because default vertical direction is from top->bottom
ár (plenty) A right turntable, it rotates movement right by 90 degrees, 'right' because default vertical direction is from top->bottom
double punctuation Rest, pauses current pointer for one extra tick (i.e. a no-op which takes 2 ticks)
peorð amusement in the beerhall? Sound, possibly a Lur, or another Norse instrument. System beep will do in hardware limited situations

Examples

Output the entire Younger Futhark:

ᛌᛁ̵ᚭᛁ̿ᚭᛁ̵̿ᚭᛁ̳̿ᚭᛁ͗ᚭᛁ̵͗ᚭᛁ͗̿ᚭᛁ̵͗̿ᚭᛁ̳͗̿ᚭᛁ̊ᚭᛁ̵̊ᚭᛁ̊̿ᚭᛁ̵̊̿ᚭᛁ̳̊̿ᚭᛁ̹̊ᚭᛁ̵̹̊ᚭᛧ

Old Norse 'Hello World', output: ᚼᛅᛁᛚ᛬ᚢᛅᚱᛅᛚᛏ

ᛋᚭᚭᚭᚭᚭᚭᚭᚭᚭᚭᚭ
ᛁ͗̿ᛁ̊ᛁ̳͗̿ᛁ̹̊ᚹᛁ̿ᛁ̊ᛁ͗ᛁ̊ᛁ̹̊ᛁ̊̿ᛧ

Historical

Buslubæn, istil formula, from Bósa saga ok Herrauðs, 15th C

ᚱᚭᚦᚴᛙᚢ
ᛁᛁᛁᛁᛁᛁ᛬
ᛍᛍᛍᛍᛍᛍ᛬
ᛐᛐᛐᛐᛐᛐ᛬
ᛁᛁᛁᛁᛁᛁ᛬
ᛚᛚᛚᛚᛚᛚ᛬

Code Runes from the Rök runestone (extract), 9th C

ᛟᛟᛌᛌᛟᛟᛌᛌᛌ

Multi-threaded

The historical examples above show ᚱᚢᚾᛅᛦ can have multiple start runes, in different forms. This is similar to Concurrent Funge-98. Each sól rune initialises a new instruction pointer, with an initial value of = 1 = 0b0000. The pointers move independently, one space per tick, with initial direction and wrapping behaviour set by the rune form as follows:

sól rune Direction Wrapping
Left-to-Right row-loop wrapping
Top-to-Bottom column-loop wrapping
Left-to-Right drop to next row wrapping
Top-to-Bottom jump to next column wrapping
  • can be used to delay an instruction pointer by an extra tick.
  • Initially every instruction pointer shares the same stack (the trunk). IP specific stacks can be branched with the Elder Futhark rune, and the branch dropped with (this probably needs some figuring out, the shared stack will need some rules to deal with 'simultaneous' access + writes, and the 'dropping' logic needs more thought)
  • Every instruction pointer, in addition to pointing to its location in the code, has 4-bit storage for a 'current value'. These are like variables. These values can be pushed to the stack for use later.

External resources