I've been playing with a new emscripten-based OS: https://www.exaequos.com. It includes raylib and Lua bindings to it, so I'm starting to feel at home. There's an app store anyone can publish apps to, but by default your changes remain in the browser's local storage. Quite slow and buggy, but it's never lost data for me yet. I just had to reload several times while trying to record this video of my first published app 😄
Kartik Agaram
http://akkartik.name/about
Member since
Jul 20, 2017
Recent Activity
My charting "library" can now draw histograms.
https://akkartik.itch.io/carousel/devlog/708682/drawing-histograms
A solver in a Sokoban client that lets you focus on the puzzle (what crate to move next, and where to move it) and ignore some of the drudgery of orchestrating steps on a touchscreen. Tap on any empty square to try to move the player there if possible -- without moving any crates. Tap on a crate and then an empty square to try to move the crate to the square if possible -- without moving any other crates.
Open source and source-editable client for playing 300 Sokoban puzzles on your phone.
A quick and dirty charting "library" in 200 LoC that can crappily plot half the different kinds of charts out there.
https://akkartik.itch.io/carousel/devlog/686788/lots-of-charts
Yo dawg, I hear you like computers, so I put a computer in your computer so you can program while you program.
https://akkartik.itch.io/carousel/devlog/685707/a-little-programming-game
A sprite editor you can paste in and run on your phone or tablet (or computer)
https://akkartik.itch.io/carousel/devlog/665231/a-sprite-editor-in-100-lines-of-code
I'm heading towards boids, but got distracted by this nice view.
https://akkartik.itch.io/carousel/devlog/660061/some-squishy-balls
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.)
A little equation plotter in 90 lines
https://akkartik.itch.io/carousel/devlog/656473/building-an-equation-plotter
4 example scripts of ~30 lines each that should be easy to mix and match on a phone or tablet.
https://akkartik.itch.io/carousel/devlog/653245/the-lua-carousel-productivity-suite
An Android voice recorder you can tweak the source code for right on your phone.
https://akkartik.itch.io/carousel/devlog/652184/a-voice-recorder-in-150-lines-of-code-well-kinda
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.
https://akkartik.itch.io/carousel/devlog/651545/conways-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.
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.
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.
https://git.sr.ht/~akkartik/crosstable.love
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
- Install LÖVE from the app store (see https://love2d.org)
- 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
https://forum.malleable.systems/t/adding-malleability-to-any-love-app/90
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.
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 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 😃
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.
http://akkartik.name/lines.html
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.
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.
https://archive.org/details/akkartik-mu-2021-05-17
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.
https://archive.org/details/akkartik-2min-2021-04-10
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
Screenception, or visualizing programs that print to screen
https://archive.org/details/akkartik-2min-2020-11-12 (video; 2 minutes)
Previous episode: https://discord.com/channels/239737791225790464/404399251276169217/770726078121377829
Main project page: https://github.com/akkartik/mu
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.
https://archive.org/details/akkartik-2min-2020-09-27
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.