Handmade Network»Kartik Agaram

Recent Activity

A quick and dirty charting "library" in 200 LoC that can crappily plot half the different kinds of charts out there.


Yo dawg, I hear you like computers, so I put a computer in your computer so you can program while you program.


A sprite editor you can paste in and run on your phone or tablet (or computer)


I'm heading towards boids, but got distracted by this nice view.


Beginnings of a mobile app you can pause any time to edit its source code. (Though the environment really needs a tablet to be usable.)

4 example scripts of ~30 lines each that should be easy to mix and match on a phone or tablet.


For the past couple of weeks I've been building little programs within Lua Carousel, my new programming environment for both desktop and mobile devices. I'm doing this partly to flush out any remaining bugs, partly to give people little ready-made programs to paste into Carousel and try out, and partly to show the project is not dead even though I'll be trying hard to avoid releasing new versions from now on.

Today's program is Conway's game of life with colors.


PSA: if you happen to be using Lua Carousel (there may be 1 or 2 of you), please consider upgrading. I've implemented one final major feature in the past week (file loading and saving) and fixed several embarrassing bugs. I'm not aware of any open bugs, which feels like a milestone.


Lua Carousel: A lightweight programming environment for desktop and mobile devices that you can make changes to while it's running.


repo: https://git.sr.ht/~akkartik/carousel.love

A new design[1] for a lightweight cross-platform programming environment that works on both computers and mobile devices. This time you can also modify its source code live while it runs (computers only).

The seed design constraint here was to structurally prevent the pop-up keyboard on a touchscreen from ever blocking my typing. That led to a multi-line commandline editor in the top half, fixing the non-editable output buffer in the bottom half. Independent commands/scripts then expanded in the only other direction available: left/right.

[1] after https://love2d.org/forums/viewtopic.php?t=94852

A silly little situated app for helping kids with school. This one drills addition by creating little 2x2 sudoku-like puzzles.

https://git.sr.ht/~akkartik/sum-grid.love (directory)
https://tilde.club/~akkartik/sum-grid.love (.love file; sorry)

Easy to run, a single download runs anywhere (including Android and iOS) once you install LÖVE (https://love2d.org; 5MB download), can be modified as it runs, and now can also be slowed down so you can see what it's doing (https://merveilles.town/@akkartik/111422018573320117)

Poisson Disc Sampling [1] while forcing myself to debug using graphical means rather than my usual bad habit of print().

It's starting to sink in that live-editing makes the boundary between debug prints and debuggers a lot more fuzzy.

[1] https://sighack.com/post/poisson-disk-sampling-bridsons-algorithm

A silly made-up problem in what I'm starting to think of as "Rectangle World".

There's a cricket world cup going on with a lot of upsets right now, and it just got me to scratch a long-standing frustration: a tool for all-play-all cross-tables that lets me simulate potential future results, while sorting the rows and columns for me.

In the process I learned to draw janky 3D-looking buttons.


As with most of my stuff lately, you can edit this app's code live as it runs, and it takes very little code to accomplish. See the Readme for details.

Achievement unlocked: kids are fighting over a program I made.

<60 LoC; it was a pretty nice experience to build it on Android using Lua+LÖVE+MiniIDE.

A silly LÖVE script written in MiniIDE on a tablet.

What you can do with MiniIDE:

  • Evaluate expressions at the console like a REPL.
  • Draw graphics either at the console or in the editor.
  • Take control over the standard LÖVE event handlers -- safe in the knowledge that you'll be returned to MiniIDE if there's ever an error.

In the video you can see me build an app that includes (inherits from) MiniIDE, so the app continues running as I type unrelated commands at the console.

You can now more easily build/run little LÖVE apps on Android

  1. Install LÖVE from the app store (see https://love2d.org)
  2. Download our MiniIDE.love from https://love2d.org/forums/viewtopic.php?t=94852


You can now make any app end-user-programmable -- as long as it's built in LÖVE


What it's like to poke inside the LÖVE apps I've been building

https://youtu.be/aD6vmbmzdBo (20 minutes)

I made a 15-minute talk and transcript (video optional) about my last year of projects and my manifesto of sorts: http://akkartik.name/freewheeling

A little app to draw graphs: https://git.sr.ht/~akkartik/snap.love

I've wanted something like this for a long time. Intended for small graphs where laying things out by hand is not too painful, and it's nice that things don't move around every time I make a change, as happens with graphviz (https://graphviz.org). The file format is also amenable to git; no long lines, and adding new nodes or edges doesn't reorder unrelated nodes and edges.

After playing with it for a bit, I notice that there's also a limit on the number of edges. Too many edges, and the dumb layout algorithm (connecting centroids of nodes) starts to creak.

Janky Mastodon thread visualizer with structured navigation


Tests using the same basic mechanisms as before:

  • There's a surface that has code on it, and now tests as well (green)
  • Zoom out to see what tests broke (red)
  • Click, Exposé-like, to zoom in anywhere


A Brainf**k interpreter and the map for its code.


A map for code. Inspired by side-scrollers like Super Mario, on startup the programming environment zooms out to take in the entire codebase before zooming in to where I left off last. The final map is for the programming environment itself, running within a "meta environment".

The driver program I use to live-edit my Lua markup language (LuaML) apps now also itself uses LuaML, so I can decide which definitions to position next to each other, pan and zoom around my desktop.

Compare v1 (https://merveilles.town/@akkartik/109182295383555872) and v2 (https://merveilles.town/@akkartik/109420170803345855) of the driver.

Current tech stack: 5kLoC for the editor widget, 500 LoC for the live-editing protocol, 1kLoC for LuaML and the driver functionality.

Plan for 2023: make this a whole Map UI for browsing the code for my apps.

After a couple of dead ends and rewrites, an infinite pannable, zoomable surface you can draw on and place blocks of text in a grid layout. The hard part was cleanly updating the viewport when scrolling within a single block editor.

I just released the repo for a Lua-based markup language: https://codeberg.org/akkartik/luaML.love
Still just a demo. Let me know if someone has ideas or suggestions for what a "minimal CSS in Lua" should look like.

God help me, I find myself building a DOM.

Instead of html it's Lua literal syntax for tables. Instead of <div> it has tables containing rows or cols. Other supported attributes: fg and bg colors, and a margin that acts like margin-top or margin-left depending on whether the parent node/table has rows or cols.

(Also, I've been developing my LÖVE apps lately in a live way where I connect to a running app and make changes to it. Takes about 500 lines of Lua: https://spectra.video/w/wkDB5fsjBNBbsqKXGhGzwT)

I've been building a live-coding setup for myself using the most minimalist stack I can come up with: Lua, LÖVE, a text editor and 500 LoC sprinkled on top.


✅ Edit source code from within the app
✅ Edit source code for source code editor from within the app
✅ Create graphical debug experiences for source code editor from within the app


As a follow-up to my jam submission, here's a game of Pong -- that can be used to edit its own source code, make changes, inspect its (graphical) log, etc.


Today I added some idioms for dividing up a log of debug prints into nestable sections, showing them collapsed by default. Here's a demo of the complete experience of opening up a log file, exploring it and potentially jumping from a log line to the precise &bifold-text code that generated it.

The editing environment only knows about lines and sections in the log file; the notion of 'session', 'game' and 'trajectory' are specific to the particular client codebase/game being debugged.

2-minute demo of how far I've gotten with &bifold-text. Ends pretty much as you would expect.

I seem to be past the "black triangle"[1] phase of my project &bifold-text, so tonight I had some fun. I built a little game using my new text editor. Here's what the source code looks like normally, and revealing debug prints. Finally, just for eye-candy, a video of me playing the game. You'll have to trust me that the debug prints work 😃

[1] https://rampantgames.com/blog/?p=7745

Not much progress today.. I may have bitten off more than I can chew. What else is new? 😅 &bifold-text

Preview of a note-taking app I've been working on: https://archive.org/details/akkartik-pensieve-2022-07-27 (5 mins)

(Youtube mirror: https://youtu.be/u3WP0Lqbj00)

It's me again (https://discord.com/channels/239737791225790464/404399251276169217/983095845635358760) with my text editor where you can draw line drawings (http://akkartik.name/lines.html). Since I published it a few weeks ago I've been receiving a trickle of feature requests. Suddenly the need to say no is not an abstraction but my lived experience everyday. Today I implemented one such request as a whole separate app: export to markdown+svg. Now people who want it have it, and the core app hasn't gotten more complex for everyone else. Repo: https://codeberg.org/akkartik/lines2md

My newest product: an editor for plain text where you can also seamlessly insert line drawings.


Built atop the LÖVE framework, with (what I think are) HMN principles.

Sandboxing in Teliva

https://archive.org/details/akkartik-teliva-2021-12-25 (video; 2 minutes)

Programming languages assume all code they run is trustworthy. Browsers assume all connections they make over a network are trustworthy. I'm starting to experiment with alternatives to these approaches. Here's one early, extremely caricatured sandboxing model that's already more flexible than both conventional languages and browsers.

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

A text mode browser for Gemini, implemented in Lua from within my platform for running, sharing and hacking on little text-mode apps.

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

Here's a 45-minute screencast of me implementing links: https://archive.org/details/akkartik-teliva-2021-12-21

A client for LiChess TV built on my platform for hackable text-mode Lua apps.

Previously: https://discord.com/channels/239737791225790464/404399251276169217/909570606876471316
Main project page: https://github.com/akkartik/teliva

New project: a runtime for text-mode Lua apps that always includes everything needed to modify and rebuild them in place.


Repo: https://github.com/akkartik/teliva

The Mu computer's network-less read-only browser now renders a lot of Unicode.

Unicode blocks now supported: latin, greek, cyrillic, armenian, hebrew, arabic, syriac, thaana, n'ko, indian (ISCII), sinhala, thai, lao, tibetan, myanmar, georgian (< U+1100)

No combining characters yet, though (https://en.wikipedia.org/wiki/Combining_character)

Previously: https://discord.com/channels/239737791225790464/404399251276169217/876714164821827605
Main project page: https://github.com/akkartik/mu

The Future of Software community doesn't have decent search, so I just built a network-less read-only browser for its archives. From scratch, running in Qemu.

https://archive.org/details/akkartik-mu-2021-08-15 (video; 5 minutes)

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

I just taught myself how to render arbitrary images in a 256-color palette using dithering

https://archive.org/details/akkartik-mu-2021-07-30 (video; 9 minutes)

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

The Mu computer now has some syntax sugar that allows me to type '1+1'. Without giving up its Lisp roots or compromising the power of Lisp macros.

https://archive.org/details/akkartik-mu-2021-06-23 (video; 8 minutes)

With that, I think I'm done inventing new notations for this particular software stack. 3 notations should suffice: compiled unsafe, compiled safe, interpreted safe. I want to leave some room for others to invent languages beyond these. From now on I'm going to focus on a few more device drivers. And lots more application programs.

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

A brief live-coding session in my Lisp prototyping environment running on my computing stack built up from scratch.

https://archive.org/details/akkartik-mu-2021-06-09 (video; 6 minutes)

Credit to Tiddlywiki for inspiring the layout algorithm, which ensures the most recently viewed functions are always on screen. I'm curious to see how long I can do without scrolling.

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

Tracking debug information more efficiently in my 80s-style Lisp-based microcomputer.

https://archive.org/details/akkartik-mu-2021-05-31 (video; 2 minutes)

Me 1 month ago: "super slow and runs out of memory, but that's a feature." (https://discord.com/channels/239737791225790464/404399251276169217/835001067355635735)

Me today: It's faster and more efficient 😄

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

A 3.5 minute video on debugging with more animation and more control of time and space.


Based on Hest by Ivan Reese: https://ivanish.ca/hest-podcast

Graphics in my 80s-style microcomputer that's built up from machine code and uses a Lisp-based HLL.

https://archive.org/details/akkartik-mu-2021-04-22 (3-minute video)

Super slow and runs out of memory, but that's a feature 😃 It's just for prototyping, and you should be throwing the prototype away and rewriting it one level down where it's easier to be memory-efficient and fast. To that end, I think I'll focus now on making it super easy and nice to write tests while prototyping, so that rewriting becomes less risky down the road.

Previously: https://discord.com/channels/239737791225790464/404399251276169217/830710757368791040
Main project page: https://github.com/akkartik/mu

More progress on what's starting to look like an '80s-style microcomputer that's built up from machine code, boots into a rudimentary Lisp, and allows exploration of intermediate steps. Most recently I've been thinking about how to distinguish between what a REPL usually prints and other side-effects explicitly requested by a program.


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

Starting to work through Make-a-Lisp[1] on my stack built up from machine code. Plan is to support Lisp's trace functionality right from the start.

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

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

[1] https://github.com/kanaka/mal/blob/master/process/guide.md

Text rendering on bare-metal x86, trying to avoid assumptions of English and left-to-right order. 2-minute video: https://archive.org/details/akkartik-2min-2021-01-12

Just 1024x768 pixels, just 256 colors. Just one fixed-width bitmap font, no bold/italics, no anti-aliasing. BUT I'd like for anybody in the world to easily be able to customize it to their language.

Project page: https://github.com/akkartik/mu

I finally got my new computing stack completely off existing OS's. It now runs on bare x86 hardware without any intervening OS kernel.

I think of this state as two 'wormholes' away from our 'universe'. In the first wormhole, Mu uses a Unix/Mac computer with just a C++ compiler to bootstrap into a self-hosted computer running on just a Linux kernel and nothing else. In the second wormhole, Mu bootstraps from a machine running a Linux kernel to a tool that emits bootable disk images that run on bare metal.

Current caveats:

  • Only supports x86. (I may have chosen wrong here.)
  • No wifi, no networking, no file system, just sectors on a local disk.
  • No multitouch, no touchscreen, no mouse, no shift keys, just some rudimentary US keyboard support.
  • No graphics acceleration, no fonts, no way to print text, just individual pixels.
  • No virtual memory, no GC, no memory reclamation. (BUT the language is designed to be memory safe. No out of bounds reads, no use after free, no creating addresses.)

Start here: http://akkartik.github.io/mu/html/baremetal/ex2.mu.html

I have the beginnings of a command shell for the Mu computer, which is built up from machine code and designed to be taken apart.

https://archive.org/details/akkartik-2min-2020-10-27 (video; 2 minutes)

A postfix shell is promising in some ways, but I'm not sure how to support concurrency. Currently each operation completes before the next. I could allow "pipe stages" to continue to share data after they drop file handles on the stack, but there are problems: how often we refresh, how we kill processes from past refreshes, how we visualize file handle contents. Comments and suggestions appreciated.

Previous episode: https://discord.com/channels/239737791225790464/404399251276169217/768366407871102998
Main project page: https://github.com/akkartik/mu

This week's 2-minute video demos a natural way to define functions from raw computations in my live-updating, spreadsheet-inspired postfix language: https://archive.org/details/akkartik-2min-20201020

Previous episode: https://discord.com/channels/239737791225790464/404399251276169217/764768182778855424
Main project page: https://github.com/akkartik/mu

Current status on my text-mode postfix language and its live-updating environment, all built up from x86 machine code: https://archive.org/details/akkartik-2min-2020-10-10

Previous episode: https://discord.com/channels/239737791225790464/404399251276169217/757270359312695336
Main project page: https://github.com/akkartik/mu

2-minute video for an extremely speculative postfix language and environment. Updates as you type, allows drilling down into function calls, and is built up all the way from machine code.


Project page: https://github.com/akkartik/mu

I've been building a tiny Markdown browser a) in my language that translates statements 1:1 to machine code, and b) with thorough unit tests for all the rendering logic without any external dependencies: https://github.com/akkartik/mu/tree/main/apps/browse

Here's a screenshot from http://akkartik.github.io/mu/html/apps/browse/main.mu.html#L81

More details on the project: https://github.com/akkartik/mu

I've been building a hackable computing stack up from scratch (machine code). Currently needs a (Linux) kernel to run, and a Linux machine to build. Initially bootstraps from C++, but after that requires no C or libc or Assembly.

Rather than start from some syntax and introduce layers of translation to implement it, Mu starts from the x86 instruction set and tries to get to some safe and clear syntax with as few layers of translation as possible.