A Lisp compiler to RISC-V written in Lisp(www.ulisp.com)

227 pointsby chrisjj17 hours ago14 comments

reikonomusha15 hours ago
SBCL is a Common Lisp compiler written in Common Lisp that also can target RISC-V.
- amszmidt15 hours ago
  Can it run on the MCU mentioned in the post? Somehow I doubt that.
  Can SBCL even target MCU boards like the pico?
  - AyyEye15 hours ago
    Second sentence from TFA:
    > You can run the compiler on the RISC-V core of a Raspberry Pi Pico 2 (or another RP2350-based board)
    McGuffin14 hours ago
    What article are you referring to? (Specifically, the parent comment asked about SBCL, Steel Bank Common Lisp, running on the pico 2, not about uLISP)
    AyyEye14 hours ago
    No more comments before coffee for me.
Pet_Ant17 hours ago
There is something about RISC-V that really inspires lots of hackers and it’s not really technical thing AFAICT.
- bee_rider16 hours ago
  It is cool as heck that truly open hardware might actually win in our lifetimes. (ARM was an interesting start, but too much licensing).
- marssaxman12 hours ago
  For me, it's the fact that it is a truly open standard, with no licensing entanglements. It has the potential to be a durable ecosystem, worth investing in.
- chrisjj15 hours ago
  > There is something about RISC-V that really inspires lots of hackers
  "Not Arm" :)
- rootnod310 hours ago
  For me, part of it is also the beauty of the ISA. I think it is just really well thought out with its extensions and namespacing for custom ISAs.
- trq0175815 hours ago
  Simplicity, it's a modern MOS 6502. Base RISC-V has even less instructions than 6502.
  - Joker_vD14 hours ago
    Also it has less registers (32 vs. 256 in the zero page) and less addressing modes.
    snvzz5 minutes ago
    Can they really be called registers, when they're bytes in DRAM?
    It really is just a convenient short addressing mode.
    The 6502 has actual registers, A/X/Y and the specialized S/P/PC.
    wk_end11 hours ago
    But the 6502's "registers" are much smaller and you can do much less with them. You can't really sensibly compare the two approaches so superficially.
    crackez6 hours ago
    Yet the same number of register bytes (when only counting 6502's zero page)... 32x8 = 256 bytes...
    brucehoult3 hours ago
    31x4 = 124 bytes :-) The Zero register doesn't have to physically exist, and we're talking about 32 bit CPUs e.g. Pi Pico 2 here, right.
    Ok, 128 bytes if you add in the PC.
    Except for RV32E -- as seen in the very popular $0.10 CH32V003 -- which has 15x4 = 60 bytes of GPRs, plus the PC.
    Plus usually a few CSRs on practical CPUs, though Zicsr is an extension so you don't have to have it.
  - acegopher11 hours ago
    The same could be said of the ARM Cortex-M0+.
    kragen11 hours ago
    The Cortex-M0's Thumb-1 is a really unpleasant instruction set compared to ARM, Thumb-2, RISC-V, or ARM64.
    brucehoult3 hours ago
    Though no worse than 16 or 32 bit x86 (without FPU), and probably better because the lower 8 registers are general-purpose.
    Also you can get something useful from the "spare" five registers r8-r12 as they support MOV, ADD and CMP with any other register, plus BX. Sadly you're on your own with PUSH/POP except for PUSH LR / POP PC.
    Thumb-1 (or ARMv6-M) is fairly similar to RISC-V C extension. It's overall a bit more powerful because it has more opcodes available and because RVC dedicates some opcodes to floating point. RVC only lets you do MV and ADD on all 32 (or 16 in RV32) registers, not CMP (not that RISC-V has CMP anyway). Plus, RVC lets you load/store any register into the stack frame. Thumb-1 r8-r14 need to be copied to/from r0-r7 to load or store them.
    But on the other hand, RVC is never present without the full-size 4 byte instructions, even on the $0.10 CH32V003, making that a bit more pleasant than the similar price Cortex M0 Puya PY32F002.
- KerrAvon10 hours ago
  It's a bunch of things; many of the reasons are actually technical. It's very simple to compile to RISC-V instructions.
  - brucehoult2 hours ago
    The offsets for J{AL} and Bcc are a little tricky, though only half a dozen lines of code to sort out.
  - zyffsht3 hours ago
    Tyyygyg
bloopernova16 hours ago
I got a RP2350 "Feather"[1] from Adafruit[2]. Amazing little thing, with lots of stuff built-in. The lipoly charge port is super useful and Just Works, and the STEMMA QT connector means no soldering or breadboards for simple projects. My main half-baked idea for this is to control a CPU usage monitor[3], but I also want to make some better lights for my Lego SHIELD Helicarrier, and maybe add some movement too.
And now you're telling me I can use Lisp on this? It would be interesting to see how streamlined the development process is for each one of uLisp, CircuitPython, MicroPython, and Arduino/C.
[1] https://www.adafruit.com/product/6000
[2] https://www.adafruit.com/new <-- one of my favourite places to window-shop :)
[3] Yeah I'm rambling but my end goal is to drive an LED matrix that ends up looking like btop's CPU meter. Why not just show btop on a separate small screen? That is a very good question to which I have no answer.
- jwhitlark13 hours ago
  Rust also runs on picos and Esp32s, if that’s your jam.
spsesk11717 hours ago
ulisp is an incredible achievement and has brought me a lot of joy.
There is something very fun about writing lisp for an Arduino nano, and trying to golf your intentions into ~300 characters :)
- bongodongobob13 hours ago
  That's neat but I don't know why you'd minimize characters rather than ROM size for a microcontroller.
kragen11 hours ago
I don't think it's yet complete enough to compile itself; though I haven't looked at the assembler code, I'm pretty sure it requires bitwise operations the compiler can't compile yet. Also, the compiler itself requires things like null, symbolp, eq, and atom, which it also doesn't implement yet. Without those I'm not sure that it's fair to describe its input language as Lisp, though it does support car and cdr.
But it's still super cool. A really great thing about Lisp for purposes like this is that you don't get hung up on syntax and parsing, which is the most salient part of writing a compiler but not the most important.
- kazinatoran hour ago
  Things like atom and symbols are functions in the runtime. A Lisp compiler only has to handle special forms, and function calls. If we see the compiler source code using a special operator that it doesn't handle, either directly using it or via macro expansion, then we know it's not yet self-hosting.
rwmj17 hours ago
As I understand it, this compiles down to assembly instructions. What then assembles it to machine code? The reason I'm asking is I wanted to find out if the compiler/assembler supports compressed instructions (which are supported by the RP RISC-V core).
Edit: Yes it does support the compressed extension, although the page calls them "compact" instructions.
- steeleduncan17 hours ago
  In the article there is a link to an earlier post with a RISC-V assembler (I think written by the same author), which generates the actual machine code
- johnsondavies16 hours ago
  Thanks - corrected "compact" to "compressed".
dang10 hours ago
Edit: It's a pity we missed http://www.ulisp.com/show?4W2I. It was posted (https://news.ycombinator.com/item?id=41190553) but didn't get attention. We'd have put it in the SCP for sure (https://news.ycombinator.com/item?id=26998308) if we had seen it.
---
Related. Others?
uLisp: Lisp for Microcontrollers - https://news.ycombinator.com/item?id=41681705 - Sept 2024 (1 comment)
An ARM Assembler Written in Lisp - https://news.ycombinator.com/item?id=36646277 - July 2023 (31 comments)
uLisp wireless message display with a Pi Pico W - https://news.ycombinator.com/item?id=32722475 - Sept 2022 (6 comments)
Visible Lisp Computer: embedded real-time display of Lisp workspace using uLisp - https://news.ycombinator.com/item?id=30612770 - March 2022 (7 comments)
uLisp on the Raspberry Pi Pico - https://news.ycombinator.com/item?id=29970231 - Jan 2022 (14 comments)
uLisp - https://news.ycombinator.com/item?id=27036317 - May 2021 (87 comments)
Lisp Badge: A single-board computer that you can program in uLisp - https://news.ycombinator.com/item?id=23729970 - July 2020 (25 comments)
A new RISC-V version of uLisp - https://news.ycombinator.com/item?id=22640980 - March 2020 (35 comments)
uLisp – ARM Assembler in Lisp - https://news.ycombinator.com/item?id=22117241 - Jan 2020 (49 comments)
Ray tracing with uLisp - https://news.ycombinator.com/item?id=20565559 - July 2019 (10 comments)
uLisp: Lisp for microcontrollers - https://news.ycombinator.com/item?id=18882335 - Jan 2019 (16 comments)
GPS mapping application in uLisp - https://news.ycombinator.com/item?id=18466566 - Nov 2018 (4 comments)
Tiny Lisp Computer 2 - https://news.ycombinator.com/item?id=16347048 - Feb 2018 (2 comments)
uLisp – Lisp for the Arduino - https://news.ycombinator.com/item?id=11777662 - May 2016 (33 comments)
Joker_vD11 hours ago
This is all very neat and all but could anyone please explain to me how this thing handles forward label resolution e.g. in the "if" construct? I think I know how it does that but I am very likely to be be wrong.
pjmlp16 hours ago
I see Lisp compilers and upvote. :)
Great work.
- patrickmay9 hours ago
  I see people who upvote Lisp compilers and upvote.
  - shsbdksn2 hours ago
    I see people who see people who upvote people who upvote Lisp compilers and I upvote.
    Thank goodness for tail call optimization.
    snvzz11 minutes ago
    I see Lisp and upvote.
    I see RISC and upvote.
- 13 hours ago
  undefined
- 14 hours ago
  undefined
anthk6 hours ago
I'd love a cheap $100 netbook with its speed close to the specs Intel Atom n270 one or similar.
Not everyone needs a 16GB machine to compile huge current C++ projects.
- snvzz8 minutes ago
  >Not everyone needs a 16GB machine to compile huge current C++ projects.
  These days 64GB is barely sufficient for that.
  We really need to switch to mold linker.
- brucehoult2 hours ago
  Oh, interesting.
  I was going to say nothing in the RISC-V world is comparable to the N100 yet, at any price, but it looks like the N100 is anywhere from 10 to 20 times faster than the N270.
  Geekbench 6 doesn't have any N270 results but it has a couple of Atom 230 results, and other sources indicate those two are very similar.
  So, ok, on Geekbench a single core of the JH7110 comes in a bit faster than the Atom 230. And it's got four of them. You can get a Milk-V Mars CM with a 1.5 GHz JH7110 with 2 GB RAM for $34. You should be able to build a decent little netbook around that for $100. It's compatible with the Raspberry Pi 4 CM, so if there is a suitable netbook enclosure for the Pi 4 CM then it should work.
  Otherwise I think the ClockworkPi DevTerm R-01 would be the closest that actually exist at the moment. The single 1.0 GHz C906 core is a bit slower and the price is unfortunately $239.
  But the MuseBook for $299 is much much better.
- crackez4 hours ago
  Vulkan shaders have entered the chat...
16 hours ago
undefined
crotho6 hours ago
[dead]
neuroelectron17 hours ago
[flagged]
- bee_rider16 hours ago
  Wait it fits in a comment? What sort of magic is this?
  - snvzza few seconds ago
    The beautiful simplicity of Lisp and RISC-V.
    Note that RISC-V has further magic in its inevitability.
  - 10 hours ago
    undefined
- johnsondavies17 hours ago
  Sorry, I'd posted the link to the code in the wrong format - corrected now. Would you like to delete that copy?
- 16 hours ago
  undefined
hinkley11 hours ago
Gretchen! Stop trying to make Lisp happen. It’s not going to happen.