Several months ago I discovered the possibilities of uLisp by David-Johnson Davies. I was intrigued by the fact that unlike MicroPython/CircuitPython this subset of CommonLisp (a niche language by today's standards, but as versatile and powerful as Python) even works with older AVR hardware. Furthermore uLisp offers the possibility to run the REPL on the microcontroller itself. That way one can build a self-contained Lisp machine without underlying operating system, which David himself first demonstrated with his Lisp Badge.
It is easy to customize uLisp to one's needs, it offers an inline assembler for the different processor types and a (currently limited, but growing) uLisp compiler. This slim Lisp core and its design really feel like a Swiss Army Knife(TM) for microcontrollers. I realized this version of the ancient high-level programming language actually is future-proof and backward compatible at the same time: You can extend it endlessly by wrapping any Arduino C library into a really simple interface format, and the whole thing runs on just about any microcontroller board - cutting edge ones as well as time-honored processors like the ATmega1284 or 2560. (Even the 328P is supported, but its tiny RAM limits the fun.) It's not necessary to port your latest high-level routines back to C anymore when an older board from your drawer can be put to good use in a project.

After some tinkering with uLisp I concluded I could migrate MCU software development to it entirely, since uLisp offers access to each and every register of a processor when needed, while its own core is so (relatively) small and well documented that the mere mortal has a chance to gradually grasp its inner workings and even modify them. Plus, David updates uLisp very carefully and thoughtfully, so a new release does not break your existing routines - broad hint, valued CircuitPython team, even if churning out new features and restructuring the modules is certainly done with the best of intentions.

The home computer of my dreams

When it turned out the LiliGO T-Deck could nicely be used with uLisp as some kind of tiny home computer while being completely open to today's and upcoming latest technology, I was hooked to that idea. But I'm not the youngest of guys anymore, so machines with really tiny screens cannot be more than gadgets for me personally. Thus, I began to pursue the idea of creating a Lisp machine that's really usable without ruining one's eyes, with a full keyboard and a comfortable editor programmed in uLisp itself that can save and load my work utilizing an SD card. Thankfully, hardware components fitting into that fixed idea are available, so the LispBox came into being as the first iteration: A year 2024 true home computer that "boots" within seconds into nothing but the REPL prompt, ready to be programmed without PC or tablet support while running at incredible 600 MHz. The printed case offers a large prototyping area to accommodate a project on breadboards with ordinary jumper cables plus up to two Feather modules. Close the lid and the current project is stowed away without cluttering your desk.

Fast forward several months, and it comes clear to me that I want an additional slightly different form factor that does not need to sit on a desk: The LispDeck, a handheld version 100% compatible with the LispBox, usable while lolling on the sofa. This is what this page eventually is about, excuse my lengthy introduction. The 3D printing files for the LispDeck are on GitHub as well, and here's the current BOM - note that the concept allows for reconfiguring most of the hardware if you like, since I decided to pinch almost every module into breadboards:

Cabling is up to you; please consult and adapt the firmware files to your choice of pin connections. Power on/off is directed to the illuminated push button and distributed to the breadboards via the mini prototyping PCB that also serves as an access point to IO pins and/or I2C etc. from the outside.

There are several options for powering the LispDeck:  There's room for either two AAA battery holders (4 cells each) connected in parallel or several Li-Ion battery packages or a small and flat power bank. The Teensy needs to have the pads connecting VUSB to VIN separated to prevent back-powering a PC connected via USB. The board expects an input voltage of 5V (thus the buck/boost voltage regulator, esp. when using Li-Ion batteries with lower voltage). The large screen should be connected to the 5V power rail as well (as opposed to powering it from the Teensy's 3.3V output) if you use the wireless boards since the overall power draw is likely to exceed 250mA then. (The RA8875 controller board includes level shifters.)

The lid with the two screens is kept shut by the tiny magnets (which adhere to the screen's metal case as well). When open, you can comfortably access the innards of the LispDeck. As already mentioned most of the electronic parts reside in the breadboards, so this is actually a prototyping area as well. To keep the case flat, though, ordinary jumper cables cannot be used here. Since the standard height of pin headers is a real pain in tight environments I opted for modified JST connectors which results in about half the height of normal breadboard stuff. Hello industry, there's room for improvement here, if you ask me. "Modifying" the connectors means that I crimped shorter male pins (really meant for who knows what, some day I intended to buy the normal larger version but received this shorter length) to wires and stuck them into JST housings. A bit hard to explain; bottom line is, to use breadboards within the case you need to connect the components with something about half the ordinary header height max - and/or flat jumper wires for additional connections.

The advantage here is that almost all components may easily be replaced anytime. When I started the project, the Teensy 4.1 was not only the fastest uLisp board available, but also the one with the largest RAM. The latter has changed; for the sacrifice of some speed, RP2350 boards and others with PSRAM now offer even much more room for storing uLisp objects. So there are several options to populate the LispDeck's guts, albeit the Teensy with its integrated SD slot that doesn't eat away any bus pins still feels very handy, not to mention its breakneck speed and a ton of I/O pins and buses.

The rotary encoder and the secondary screen are accessible from uLisp, of course, and can serve the development of any project you come up with. But within the fullscreen editor this duo also forms the "Lispy Little Helper", a Rolodex-like access surface to uLisp's built-in documentation - please see the GitHub page for further information. The touchscreen controller and the RFM69 module are also available within uLisp via the LispDeck firmware, i.e. uLisp extensions. The WLAN module can be controlled with "AT" string commands by invoking the "stream" mechanism typical for Lisp that allows to simply print to any serial connection (and several other I/O mechanisms). Using the "USBHost_t36" library for the Teensy the keyboard's touch pad probably is accessible as well, but I haven't explored that yet.

So why deviate from the usual and proven Raspberry Pi Cyberdeck path at all? Because I really like to be able to completely understand and control the machine down to the last bit like in the aforementioned old days, but without being stuck in the 8-bit past. True, theoretically that's possible with the beloved RPi as well, but only if you're willing to digest millions of Linux source code lines. The LispDeck, on the other hand, offers computing oomph miles beyond ancient "Cray" superpowers, on boards the size of a chewing gum stick or less, available at pocket money prices and designed to withstand even clumsy tinkerer's hands like mine (did I really produce a short circuit again? oops...). I'm still in awe on today's possibilities, god forbid they vanish in a juicy alternative facts barbecue of unshaven drunk people wearing cow heads.

Oh, I almost forgot to repeat: That's really Lisp, yes... it's not Python that everyone talks now, right? Trust me: It's well worth dealing with this age-old programming language, and if you already know Python, you will quickly grasp Lisp after some experiments (and checking out the excellent short tutorials on the uLisp website). At university I had to attend a mandatory Lisp course, and back then I soulfully hated Lisp, because 1) I thought "why the heck count all these Lots of insulting superfluous parentheses" and 2) exercises exploring the exciting differences between commands from hell like CAR, CADR, CDDAR and so on drove me mad.
Well, today I think they were right when saying it's worth learning Lisp, they just taught it the entirely wrong way, IMHO. But it's 2025, editors (like the one in the LispDeck firmware) with parenthesis matching relieve us from counting the little buggers, CAR may be called FIRST now, and controlling LEDs and servos and whatnot with uLisp is so much fun you might start to appreciate this old ingenious strangely powerful language that already offered so many features introduced in other programming environments only many decades later.

Give it a try!


Further reading:

Die Lisp-Box (at Make: Germany)
(in German, paywall)