romanzolotarev.com is a Fediverse instance that uses the ActivityPub protocol. In other words, users at this host can communicate with people that use software like Mastodon, Pleroma, Friendica, etc. all around the world.
This server runs the snac software and there is no automatic sign-up process.
Ok! Spent all weekend starting on a #uxn exploration by implementing uxn from scratch.
Ended up using JavaScript even after all my complaining because I'm intending to make a single shareable .html file that acts both as the full vm implementation inlined, but also generates documentation from its own opcode definitions, which is fun~
I'm also making the code painfully verbose for each opcode. There's only and handful of them and they're not complicated but all the official implementations are suuuuper compact code, which caused me misunderstandings when trying to understand some.
Every time I play with uxn I need 2-3 wiki pages and a hex calculator open, so hopefully if I finish this I'll have myself a full single-page version with a hex calculator and a uxn implementation and a text-editor.
Here's a cute little live vm-viewer component I just finished adding to the page~
Now also on itch.io, where you can play it without downloading:
Finally got a few hours to sit down and made little techdemo for my new fully-featured #uxn RPG text-renderer ^__^
All the dialogue uses a DSL I wrote overtop of TAL, an example is here: https://paste.sr.ht/~angelwood/4ecd01665b30e32ad3ee0f783428692f7043cb13
( The Framerate in the recording is a little messed up but the text speed is faster/slower in an emulator )
#Uxn's ridiculous face on the Playdate looks like it's wearing a yellow parka and that only the narrow of the face is showing.
μxn-100 is ready!
I have done some tests and I like this, let me know if you have any suggestions. I will make a live stream later today and then edit that into a nice intro video to uxn.
I recommend using light colors and pencils to reuse the sheet if needed (printing a page is all you need).
Best to print on both sides or use recycled paper if you want a bunch. Should be a perfect teaching and learning tool for children and adults alike.
PDF: https://git.sr.ht/~ismael-vc/muxn-100/blob/main/paper-muxn-100.pdf
List of English words forbidden as labels in uxntal:
a
abed
accede
acceded
ace
aced
ad
add
added
b
baa
baaed
babe
bad
bade
be
bead
beaded
bed
bedded
bee
beef
beefed
c
ca
cab
cabbed
cad
cc
cede
ceded
cf
d
dab
dabbed
dad
dd
dded
dead
deaf
deb
decade
decaf
deed
deeded
deface
defaced
e
ea
ebb
ebbed
ed
efface
effaced
f
fa
facade
face
faced
fad
fade
faded
fed
fee
feed
=0a |\n
=18 |Console/write
{putc ( char -- ) .LIT .Console/write .DEO }
[ ( push address ) '' @ ]
.LDAk ^putc .INC2 ( >> )
{println ( str* -- )
.LDAk [ ( consume address ) *^? ]
.LIT2 .\n .Console/write .DEO }
'hello world' *println
syntax: <whitespace...> [rune][data] <whitespace...> [rune][data]
parser skips until first non-whitespace byte, then handles that as a rune
runes are like reader macros, they have access to the input stream and can read as much data as they want
for ', " and (, they would read until the matching char
for the rest, they would read a word
word can be a number or a label, it's up to the rune to handle it
e.g. .label expects a label and writes its lower byte, while =0a expects a hex string and writes it as a short
runes execute immediately
"hello world"-42 =cafelabels have values
feels kinda verbose idk what do yall think
especially compared to a lang like painterForth (https://git.sr.ht/~hocwp/painterForth) which switches state, might look something like:
- .LIT2 .\n .Console/write .DEO
+ .LIT2 \n Console/write DEO
visually cleaner! but can make parsing ambiguous (what counts as a rune?)
Took a little bit to figure out libraries and such, but I finally figured out how to render .ttf true type fonts into .uf2 files for rendering in #uxn
I want to learn #C and #Zig (I've written a couple small programs in zig 0.13 and liked it), but all my (15+ y) real experience is in python and javascript. I use those at work and they've started to feel... dirty? Infected?
They've become productivity-coded to me because of work, and I want to code for the love of coding but all my py/js experience makes lower level langs feel unintuitive and needlessly complex.
I also *detest* the compile step. Makefiles and linked libraries make me want to gag the same way package managers seem to set off systems devs, and any time I get to the part where i need to tinker with a build.zig or figure out how to make SDL3 work I get super turned off, even if I enjoy the structure and control the languages afford.
(Watching a wall of warnings fly by as I try to compile hello world for an esp32 does not instill confidence in my code or feel low level to me lol)
My recent experience with #uxn was the best #programming experience of my life -- knowing my code did what i wanted byte-for-byte, and that the compile step was effectively just turning symbols straight into bytes was super intuitive. It was also far enough from py/js that my bad habits didn't impact my experience. Uxn is intentionally small, though... not for everything.
I'm still toying with the idea of starting to write raw #wasm. It doesn't spark as much joy as uxn does, but has a similar mouthfeel.
This essay doesn't have a real conclusion; just venting.
ok, silly concept: Uxn programs have a chirality, identified by which of the two stacks is used for return addresses and which is used for values. as long as there is no self-modifying code to the degree that opcodes are changed at runtime, i *think* you can statically transpose a program from one chirality to the other, just find every opcode (with the exception of BRK, JCI, JMI, JSI, and avoiding immediates) and flip 0x40... almost. JCI only reads from WST. :(
it was brutally slow to run on an emulated mac plus but the mandelbrot2 #uxn rom actually looks kinda awesome in black & white
Friends of pixel art and cozy computers, i made a thing. i adapted @j-g00da's KAMIOKANDE DREAMS as an Uxn ROM!
I just realized that I can pipe ANY streamable image data.... so I accidently also made a #uxn webcam!
I know I shouldn't be surprised that it just works as is, but still cool, I can build compile uxn binaries directly inside dos.
wcl -bt=dos -ml -fe=bin/uxnmol.exe src/uxnmol.c
Some days we have no power, others no reception, once in a while we have neither. Today was such a day, the oppressing low skies suffocating the signal and covering our solar panels didn't allow for much virtual fussing.
But while penciling out storyboards for our #Catjam entry, Rek pointed out that it might be nice to have a Yufo cameo aboard the train. Genius idea! Let's look at the actual state of that ol' thing.
Written in a haste during the Virtual Pet Jam a few years ago, its codebase was horrendous; Uxn was quite young at the time, the linter in its infancy too. It ran just fine but needed a bit of love if the codebase was ever going to be something worthy of being looked at by anyone.
So, I spent the little power I had left in my laptop rewriting it all in a more standard Uxntal style, with the typical video game OOP patterns that makes the more recent roms somewhat robust. It runs faster, looks and feel nicer too. I've published a new build with metadata and all the other niceties of modern #Uxn projects.
If anyone ever asks who that weird antlered creature on the train is, at least we can be proud to point to Yufo.
Someone just demonstrated that the entire Uxn toolchain can be reconstructed from nothing but a POSIX shell, xxd and sed. It's down to taking 34 minutes to build the Uxntal assembler.
bootstrap: https://joe.cz/uxn/uxn1b-drifloon.txt
repo: https://gitlab.com/racketeer/uxnsh
#uxn