Undâr Programming Language

• NOTE: THIS IS ARCHIVED VERSION CURRENTY BEING REWRITTEN new version
• Undâr
• Philosophy
• Getting Started
• Memory Management
• Roadmap
• License
• Inspirations

NOTE: THIS IS ARCHIVED VERSION CURRENTY BEING REWRITTEN new version

[ᚢ  ᛫  ᛫  ᛫
 ᛫  ᚾ  ᛫  ᛫
 ᛫  ᛫  ᛞ  ᛫
 ᛫  ᛫  ᛫  ᚱ]

Undâr

Undâr is a programming language for the purpose of creating 3D games and graphical user traits that work on constrained systems, microcontrollers, retro consoles, and the web using emscripten. The language emphasizes hardware longevity, energy efficiency, and the preservation of digital art and games for future generations.

It runs on the Reality Engine, a VM written in freestanding C89, has a CISC like instruction format of one byte opcode and a variable byte operand. 32 local variables per frame.

Philosophy

Undâr conforms to permacomputing principles.

"permacomputing encourages the maximization of hardware lifespan, minimization of energy usage and focuses on the use of already available computational resources. it values maintenance and refactoring of systems to keep them efficient, instead of planned obsolescence, permacomputing practices planned longevity. it is about using computation only when it has a strengthening effect on ecosystems." source

Undâr is designed to ensure that programs created today will remain executable for a very long time, even through technological collapse.

This is achieved through:

• A standardized bytecode format that maps 1:1 to human-readable IR
• A VM specification that can be implemented easily
• Hardware abstractions instead of a 'one size fits all'.
• ROM files that allow for a 'compile once run anywhere'.
• A friendly syntax which focuses on maintaining code without obscuring functionality.

Getting Started

Build the Reality Engine

git clone https://git.alfrescocavern.com/zongor/undar-lang.git
cd undar-lang && make

Sċieppan is a intermediate representation. You can view some examples in the .ul.ir files in /test

Sample Program: hello.ul.ir

global str terminal_namespace = "/dev/term/0";
global str new_line = "\n";
global str hello = "nuqneH 'u'?";

function main () {
	str msg $0;

	load_address hello -> msg;
	call pln (msg);
	exit 0;
}

function pln (str message $0) {
	plex term $1;
	int msg_length $2;
	str nl $3;
	int nl_length $4;
	int mode $5;
	str term_ns $6;

	load_immediate 0 -> mode;
	load_address terminal_namespace -> term_ns;
	syscall OPEN term_ns mode term;
	string_length message -> msg_length;
	syscall WRITE term message msg_length;
	load_address new_line -> nl;
	string_length nl -> nl_length;
	syscall WRITE term nl nl_length;
	return;
}

./build/linux/undar-linux-debug ./test/hello.ul.ir

Memory Management

memory is managed via frame based arenas. function scopes defines a memory frame.

heap allocations using the internal malloc opcode push pointers within this frame. when a frame exits, the pointer is reset like stack based gc.

global str terminal_namespace = "/dev/term/0";
global str prompt = "Enter a string:";
global str new_line = "\n";

function main () {
	int mode $11;
	str term $10;

	load_address terminal_namespace -> term;
	load_immediate 0 -> mode;
	syscall OPEN term mode term;

	load_address prompt -> $7; 
	string_length $7 -> $8;
	syscall WRITE term $7 $8; // print prompt

	str user_string $9;
	load_immediate 32 -> $8;
	malloc $8 -> user_string;
	syscall READ term user_string $8; // read max 32 byte string

	call pln (user_string);
	exit 0;
}

function pln (str message $0) {
	plex term $1;
	int msg_length $2;
	str nl $3;
	int nl_length $4;
	int mode $5;
	str term_ns $6;

	load_immediate 0 -> mode;
	load_address terminal_namespace -> term_ns;
	syscall OPEN term_ns mode term;
	string_length message -> msg_length;
	syscall WRITE term message msg_length;
	load_address new_line -> nl;
	string_length nl -> nl_length;
	syscall WRITE term nl nl_length;
	return;
}

values passed to functions must be explicitly returned to propagate. heap values are copy on write, so if a value is modified in a child function it will change the parents value, unless the size of the structure changes then it will copy the parents value and append it to its own frame with the modification. this allows for the low resource usage of a C but the convenience of a Java/Go without the garbage collection.

Core Types

Type	Description
byte	Character/8 bit unsigned int
i8	8 bit signed int
u16	16 bit unsigned int
i16	16 bit signed int
int	32-bit signed integer
nat	32-bit natural number
real	Q16.16 fixed-point real number
str	fat pointer [length + data] string
bool	true/false

primitive types like int, nat, real, etc. will always be safe to change in child frames.

complex types like str plex or arrays will be u32 pointers to their location in the 'heap'

Roadmap

Compiler, Plex, Immidate mode GUI, Constructive solid geometry, Tunnels, Actor model

License

MIT-0

Inspirations

• Plan 9 / 9P - Unified I/O, Tunnels.
• Lisp - Live coding, REPL, introspection.
• Fortran - Array semantics.
• C / Zig - Portability, control, minimalism.
• Lua - Friendly syntax, portable, and minimal.
• Lox - The start of my programming language creation journey.
• Uxn - Major inspiration, espeically around the core VM.
• Dusk OS - A much better system for doing permacomputing.
• Dis VM - CISC VM structure
• Retro Systems - N64, PS1, Mac Classic, Windows 95 - UI esthetics