ᚱᚢᚾᛅᛦ

From Esolang
Jump to navigation Jump to 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

Retrieved from "https://esolangs.org/w/index.php?title=ᚱᚢᚾᛅᛦ&oldid=62906"