Mar 7, 2021
Visualizing function calls with anonymous functions

https://github.com/akkartik/mu

A session of the Mu shell running in Qemu. An anonymous function to add two numbers returns the right result, and a partially expanded trace elucidates how it got to the answer.

permalink

* *
Mar 5, 2021
It's alive.

A screenshot of a Lisp running inside Qemu, showing the evaluation steps for (+ 1 1)

The same command expanding steps for tokenization rather than evaluation.

Screenshot taken while debugging the program showing debug by print (of the entire trace at once)

https://github.com/akkartik/mu

permalink

* *
Mar 4, 2021
I really wish I'd read Kragen Sitaker's https://dercuano.github.io/notes/forth-assembling.html before I built SubX.

permalink

* *
Mar 3, 2021
I took a stab at reorganizing Mu's directory tree. It had gradually sprawled from old stuff at the top-level to new stuff in sub-directories. Now the top-level contains what I want people to see first, and build tools for each directory are in a sub-directory.

Building a disk image before:

./translate_mu_baremetal baremetal/life.mu

After:

./translate life.mu

Building an ELF binary before:

./translate_mu apps/hello.mu

After:

cd linux; ./translate hello.mu

https://github.com/akkartik/mu#readme

permalink

* *
Mar 3, 2021
Have you cloned the Mu repo and tried to make sense of it? Do you have any suggestions for improving the directory organization? I'm starting to revisit it, so would appreciate any thoughts you have. (Even if this gets you to clone the repo for the first time.)

https://github.com/akkartik/mu

permalink

* *
Feb 25, 2021
Drilling into computations on the Mu shell

This was one of the more difficult things I've built, and yet all I've gotten working so far is some rudimentary tokenization. The reason is one little feature.. well, take a look for yourself.

https://archive.org/details/akkartik-2min-2021-02-24 (video; 2 mins)

Screenshot of the Mu computer running within Qemu, showing a command typed in in cyan, results in grey and an overview (trace) of the computation performed in blue.

As always, built all the way up from machine code, and designed primarily to be easy to build, easy to run, comprehensible to others. Also this time with lots of tests.

https://github.com/akkartik/mu

permalink

* *
Feb 21, 2021
I'm working through Make a Lisp with Mu

So far I'm done with https://github.com/kanaka/mal/blob/master/process/guide.md#step-0-the-repl, albeit with some tweaks since it's baremetal

https://github.com/akkartik/mu/tree/main/baremetal#readme

REPL stub running in Qemu that always returns

permalink

* *
Feb 19, 2021
An experimental way to do control flow in the postfix Mu shell

The screenshot below shows an idea I've been playing with.

Screenshow showing the Mu shell running without an OS within Qemu. Below each word typed in is the state of the stack after the word was executed. Most words push things to the stack. The <code>break</code> word skips future words until a <code>}</code>, so some later words don't show stacks.

The conventional way Forth does control flow is a little confusing with words like if and then showing up at the end.

Factor uses quotations to put code blocks on the stack. But then you see a potentially complex chunk of code executing "all at once".

Main project page: https://github.com/akkartik/mu

permalink

* *
Feb 14, 2021
The Mu shell is now off Linux

https://archive.org/details/akkartik-mu-shell-20210214

Screenshot of a postfix arithmetic expression within Qemu showing the stack after each word.

Starting point for the sources: http://akkartik.github.io/mu/html/baremetal/shell/line.mu.html

The architecture is now much cleaner. Functions contain lines, lines contain words, words contain gap buffers. Rendering a thing renders its constituent things. Render takes a top-left coordinate and returns a bottom-right coordinate. Each thing knows which constituent thing has its cursor, shows its cursor when rendering, redirects incoming keystrokes to it.

https://github.com/akkartik/mu

permalink

* *
Feb 13, 2021
I've been reimplementing my from-scratch live-updating postfix shell to really from scratch (no more OS kernel), while at the same time rewriting the prototype with lots of tests and actually giving the language some sort of rigorous basis. No demos yet, but in the meantime here's Conway's Game of Life running on baremetal Mu.

Screenshot of Conway's Game of Life within a Qemu window.

https://archive.org/details/akkartik-mu-life-2021-02-13

Sources: http://akkartik.github.io/mu/html/apps/life.mu.html

Main project page: https://github.com/akkartik/mu

Standing offer: I would love to collaborate on a computing stack for a non-English language by forking https://github.com/akkartik/mu. It's very barebones and not afraid of radical experiments. It already has an API for rendering arbitrary UTF-8 strings and returning arbitrarily-sized bounding boxes for what was rendered. So the work is mostly creating glyphs for combinations of codepoints. And rules for segmenting. And lots of testing.

permalink

* *
archive
projects
writings
videos
subscribe
Mastodon
RSS (?)
twtxt (?)
Station (?)