*2020: Flood-filling the Mu computer*

A year ago I had a prototype of a C-level programming language mapping 1:1 to Assembly that I _thought_ could be type-safe.

Since then, I:

* wrote an academic paper on it
* made it type-safe
* began a high-level language atop it
* got into video, with 15 2-minute screencasts
* and ran programs written in it on bare metal, without an OS, like, 5 years before I expected to.

❤️ to everyone who inspired, taught, debated, encouraged.

https://github.com/akkartik/mu

My 2020 wrap-up is turning into a bit of a rabbit hole:

http://akkartik.name/post/mu-2020

I ended up trying to create a Wardley Map (https://en.wikipedia.org/wiki/Wardley_map) for Mu.

https://github.com/akkartik/mu

*Rendering text atop baremetal*

Mu can now render text atop baremetal x86.

Try clicking around from http://akkartik.github.io/mu/html/baremetal/ex5.mu.html

The boot-up machine code reads a few sectors from disk, configures a keyboard handler, and loads a bitmap font (2KB for ASCII, with the option for more).

I use GNU Unifont. I believe that means Mu is now GPL v2. So stated. IANAL and I try not to think about software IP. But a font? Copyright seems reasonable there.

Next up: a text editor!

https://github.com/akkartik/mu

*A more international interface for rendering text*

New 2-minute video: https://archive.org/details/akkartik-2min-2021-01-12

You get just one fixed screen resolution: 1024x768, 256 colors. Widely available on modern machines, no drivers needed.

You get just one fixed-width bitmap font. No bold/italics, no anti-aliasing.

BUT it won't make assumptions about English and left-to-right order. I eventually want anybody to be able to customize it to their language.

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

I've been trying to visualize the default 256-color palette I get on baremetal.

http://akkartik.github.io/mu/html/baremetal/vga_palette.html

To my eyes it looks like I can/should just live in the first 128 colors.

I built a game of "snakes", but it came out more like an etch-a-sketch 😄

http://akkartik.github.io/mu/html/baremetal/ex7.mu.html

Play it on any non-windows:

```
git clone https://github.com/akkartik/mu
cd mu
./translate_mu_baremetal_emulated baremetal/ex7.mu
qemu-system-i386 disk.img
```

h/j/k/l to draw

I made an art! On a computer without an OS.

https://github.com/akkartik/mu

It took a while, but I've finally ported a pre-existing Mu program to baremetal: an RPN calculator.

This was _hard_, purely because of cursor management. I have a greater appreciation for everything that display hardware and terminal emulators provide for text mode. Mu so far puts the onus on the programmer.

http://akkartik.github.io/mu/html/baremetal/rpn.mu.html

In the end it's interesting to visualize the changes I had to make:

vim -d apps/rpn.mu baremetal/rpn.mu

They're entirely in `main`; the rest is unchanged.

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.

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

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

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

The Mu shell is now off Linux

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

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

An experimental way to do control flow in the postfix Mu shell

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

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

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

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)

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

It's alive.

https://github.com/akkartik/mu

Visualizing function calls with anonymous functions

https://github.com/akkartik/mu

Today was documentation day

Primitives available in the Mu computer when running without an OS: https://github.com/akkartik/mu/blob/main/vocabulary.md

Primitives available when running on Linux: https://github.com/akkartik/mu/blob/main/linux/vocabulary.md

For starters I focused just on making things more discoverable. These files are optimized for opening in your text editor, jumping to definitions to see type signatures, etc. See https://github.com/akkartik/mu/blob/main/editor/exuberant_ctags_rc for a ctags configuration for Mu and SubX programs.

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

Mu can now read from an ATA (IDE) disk drive on Qemu.

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

It wouldn't have been possible without the lovely folks over on #osdev. And the inspiration of ColorForth (https://merveilles.town/@akkartik/105906716550232992), though I still don't understand how that driver works.

The Mu computer now has drivers for disk and mouse.

Still extremely klunky. IDE disk drives only, and the mouse driver uses polling because configuring IRQ 12 is still beyond me.

Example programs (as usual memory safe and translating 1:1 to x86 machine code)

Disk: http://akkartik.github.io/mu/html/ex9.mu.html

Mouse: http://akkartik.github.io/mu/html/ex10.mu.html

Here's video of the mouse example. There's no pointer so you have to imagine me moving the mouse around.

Like I said. Klunky.

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

I should just go pay for Dyalog APL.

fact← {0=⍵:1 ⋄ ⍵×∇ ⍵-1}

https://en.wikipedia.org/wiki/Direct_function

via* https://www.youtube.com/watch?v=z8MVKianh54

Thanks @dogstar for the recommendation.

I currently have several tabs from https://www.sacrideo.us open, and it's very jarring that it has the same favicon as my own website 😂

@akkartik Such an exciting project. Congrats on the progress!

@akkartik well done! It has been nice to see it mature

@akkartik the title O_o

@akkartik Welcome to the middle layer.

@akkartik YEEEEEEEEES!

@akkartik
ed?

@akkartik so in theory you could boot this on an actual x86 machine and use it now as an independent os?

@jameschip Yeah, in theory. It works on both Qemu and Bochs, and it's just relying on a keyboard and screen, so I'm hoping any mistakes aren't too arduous to debug.

On the other hand, I'm a total noob on the OS/hardware side of things. I briefly tried booting it on a Thinkpad T420s a couple of weeks ago. I couldn't even get the boot sector to print text to screen using BIOS primitives. Any testing/advice most appreciated.

@akkartik I can’t offer any advice unfortunately. I, like you, am just an interested tinkerer. I once thought about doing something like this to boot on a raspberry pi but I didn’t have the time for the scale of the problem at the time.

This is impressive and interesting stuff though. Congratulations.

@akkartik I'm not sure I understand what break 3 does?

@neauoire They're separate words. Break skips remaining words until a `}`. There will be a similar word called `loop` to jump backwards to a `{`. And some conditional way to skip a word or word group surrounded in {}

@akkartik ah yeah! The way Forth does loop and conditional is one of the most awkward thing in the language I find. For Uxn I didn't want to have this since it felts infix in a way.

@neauoire Yeah.

I've basically been trying to plan out a series of code examples:

- factorial
- pushing n numbers starting from 1
- binary search over a sorted array (inspired by this screenshot from https://vimeo.com/36579366)

My examples are kinda square, like me 😄 Other suggestions welcome. For some corpus of examples I want to make it really nice to browse the intermediate states of the computation.

@akkartik Oh wow, that's like a Mu Rosetta! I'd love to browse that when it's live

@akkartik nice!

@akkartik Lambdamu

@neauoire 😂

I've been thinking of it as mulisp. Or maybe even just Lambda as the layer above Mu?

@akkartik I've been thinking about something, did you watch the talk s-ol shared about smalltalk running on top of lisp, from yesterday?

It has gotten me thinking about implementing a Uxn assembler in Uxn itself, so I could write/assemble uxn programs from within the system.

Do you have something like this in Mu? Is lisp going to be that intermediary language for you? Any suggestions/lessons on this topic you could share?

@neauoire Uxn assembler in Uxn sounds eminently doable! Now I'm interested.

A full Smalltalk/Lisp like in that talk is a _lot_ of work. The final complexity discourages looking under the hood. Which rubs me the wrong way. Maybe you too.

The very notion of 'language' tries to pretend there's nothing underneath, which might be counter-productive.

So I'm still feeling my way with Mulisp. Maybe it's going to stay a toy, a gateway drug for kids to get into the level below.

@akkartik so cool.

@akkartik
it's all fun and games until your anonymous functions become a couple lines long ;)

although at least with lisp its trivial to print only e.g. one form deep to keep it short

@s_ol The hope is that anything with this visualization will be easier than without it. It admits skipping past the long forms to drill down to the critical places, which could be short.

Though pretty printing is also an option. It's fairly well-understood for Lisp (though not by me 🙂)

@akkartik What part is confusing?

@akkartik it's free for personal use! you used to have to register for it but i don't think you need to anymore.

@akkartik Aaron's work/talks are really neat.

@akkartik so cool! I’m so glad someone is seriously doing this work. A really great experiment — hopefully it shows us all a fundamentally new way to do things!

@akkartik regarding your overall goal of communicating a codebase, you may be interested in my FuzzySet interactive documentation which attempts to give the best possible human explanation of the code library: http://glench.github.io/fuzzyset.js/ui/

@akkartik instead of building from the code "up" I tried to design from the UI "down" — what UI do we need in order to communicate programs really well and then how can we change programming so those explanations just fall out.

I love your approach of rebuilding the foundations, though! Can't wait to see where it ends up

@glench My hope is to meet somewhere in the middle with all the people doing cool UI research!

@akkartik

Wow, your Mu work reminds me very much of PL/360! Same sort of idea, but generations of hardware apart.

@vandys Thank you! I'll have to go reread my PL/360, but elaboration most appreciated.

@vandys Very interesting: https://en.wikipedia.org/wiki/PL360 I was earlier confusing it with the System/360.