There's also the ultra-minimalist part. Picolisp has like one data structure, it's two cells with pointers, and that's it. Maybe symbols are implemented in some other way, I'm not sure, but pretty much everything is based around that.

Portability is not a concern. Either you run something 64 bit POSIX or you aren't going to use Picolisp (except if you get your hands on an old 32 bit build). I think it's usually tested by a user on OpenBSD but outside of Debian you're basically on your own.

There are like three basic data types. Fixnums, symbols and the linked list. If you do something similar to what you're showing from SBCL (or LispWorks, didn't read closely enough at first) it'll look pretty much like it does in source.

     $ pil +
     : (de myfun ()(prinl "yo")(prinl "world"))
     : (cdr myfun)
     -> ((prinl "yo") (prinl "world"))
     : myfun
     -> (NIL ((prinl "hey")) (prinl "world"))
     : (myfun)
     yo
     world
     -> "world"
     : (set (cdr myfun) '(prinl "hey"))
     -> (prinl "hey")
     : myfun
     -> (NIL (prinl "hey") (prinl "world"))
     : (myfun)
     hey
     world
     -> "world"

Hijacking the 'de mechanism is not something you'll do often, but looking at definitions like this you'll do a lot, and from time to time navigate it with list browsing functions.

It boils down to some very simple interpreter behaviours, and after some time surprises become quite rare. I find it takes off quite a bit of cognitive load when solving non-trivial scripting tasks compared to e.g. bash or Python. Especially since 'fork and 'in/'out are so easy to work with, with the former you just pass in an executable list, '((V1 V2 Vn)(code 'here)(bye)), with the latter you get a direct no-hassle connection to POSIX pipes.