4.1 KiB
Konilo Manual
There is significant interest in a more traditional manual, so
this will (eventually) contain it. Expect it to be raw and very
unfinished at this point.
Document Format:
I'm going to be using a Markdown-like format for this, but it's
not strictly Markdown. Tooling to create various formats from it
will be implemented as part of the process.
Questions / Topics
- what is konilo
- relationship between konilo & retroforth
- ilo computer
- introduction to forth
- stacks
- words
- dictionary
- sigils
- combinators
- konilo applications
- block editors
- basic editor
- tuhi
- rem
- catalogue
- manual
- kohure
- wisp
- wiki
- ripanga
- konilo frameworks
- termina
- kaute
- graphica
- techniques
- assembly programming
- host-specific things
- x86-native
- teensy
- basic interactions
- installation
- starting konilo
- exiting konilo
- listener
Introducing Konilo
Konilo is a small, pragmatic personal computing system written in Forth and running on a tiny virtual computer.
It's not something intended to be widely used. It's a deeply personal system; I publish it in hopes that others may find it useful, but making a system that appeals to a broad audience is not my goal.
Konilo is a small system. A barebones system is just over 2.5k memory cells, and provides a functional Forth environment including the compiler, block editor, and interactive listener. A fully extended system, with an expanded vocabulary of words and several additional applications is under 10k.
Forth is at the heart of Konilo. It's not a conventional choice, but over the last few decades I've become very comfortable with it, and, in setting out to create a personal computing system, have found it to work well. My Forth is not a traditional model. I use a very minimal dictionary, and make extensive use of both sigils and quotations, leading to an implementation that feels quite different from classical Forth systems.
The entire system runs on a virtual computer. This is a path I started for portability reasons, and one that I've found quite practical. Through the use of a virtual computer, Konilo has been demonstrated to run on hosts from the late 1980's through modern machines.
Konilo and RetroForth
Konilo is similar in many respects to RetroForth. Both derive from classical Forth, adding in sigils, quotations, and use of combinators for logic and flow control. Both have similar core vocabularies, and (in general) it's easy to write programs which work on both.
But Konilo has some important changes. From a language viewpoint the major three are a much more limited dictionary structure, a removal of word classes, and a completely different model for strings.
RetroForth tracks a lot of data for each defined word. Konilo does not. A comparison of the structure:
RetroForth Konilo
---------- ----------
d:link d:link
d:xt d:address
d:class d:hash
d:source
d:hash
d:name
Note that Konilo lacks the d:class, d:source, and d:name fields.
Word classes are removed. In RetroForth, the contents of the d:xt field are placed on the stack, and a word class handler function is called during interpret or compilation. In Konilo, the system handles two cases (normal vs immediate), with all other functionality handled by the sigils.
The other big change is strings. In RetroForth strings are null terminated sequences of characters. This is perhaps less than ideal for a variety of reasons, but keeps compatibility with previous generations of the system. Konilo, being a completely fresh start, changes this, so that strings are character arrays.
ilo computer
ilo is the virtual computer Konilo runs on. It implements a misc-style stack processor, 64k cells of memory, and several i/o devices. Implementations are small (between 100-500 lines of source is typical) and easy to write (most implementations have taken only a few hours to write & debug).
frameworks: termina
Termina is the basic scaffold for many of the programs in Konilo.
frameworks: graphica
frameworks: kaute
Kaute is a new scaffold for creating simple spreadsheet-like programs.