lone

> Hardly anything is written against the kernel ABI except glibc itself. I'm working hard to change that. Here's an entire lisp interpreter written in freestanding C using nothing but Linux system calls: https://github.com/lone-lang/lone It has a system-call primitive too, which means it can do anything. Here's a TCP echo server written in lone lisp: https://github.com/lone-lang/lone/blob/master/examples/tcp-e... It works, and you don't need libc. > Like it or not, glibc is the singular entry point for desktop Linux Well I don't like it, and I've made it my mission to fix it. Maybe lisp isn't the answer, Rust is. I've revived my liblinux crate too. https://github.com/matheusmoreira/liblinux I'm going to add system calls to this thing every day until I have every single one. Then I'll use them to make all of my applications. Already have m

https://github.com/lone-lang/lone Sent a PR to breck7/pldb and it got merged in less than two minutes.

Thanks for reading and for your interest in lone! > I also love the APE setup Yeah, jart's cosmopolitan is awesome. I've even sent some floating point code her way! I have my own take on the "embed data into the executable" problem too. It's the one thing I've made that I think is truly novel. I developed a tool to copy the data into the ELF in such a way that Linux mmaps it in automatically. Lone can just reach it at runtime via the auxiliary vector. No need to read /proc/self/exe. You might enjoy this article: https://www.matheusmoreira.com/articles/self-contained-lone-... The ELF editor is written in C right now. I'm getting the language ready to host it as a lone application. That'll make it easy to redesign this feature and develop even more high level features on top of the code loading. https://github.com/lone-lang/lone/issues/8

You might enjoy my work on the lone lisp language. I got rid of the libc and implemented an entire interpreter with nothing but Linux system calls. Been working on it and blogging about it for about 3 years now. http://github.com/lone-lang/lone/

I call it the lone programming language. https://github.com/lone-lang/lone/ It's a lisp interpreter with zero dependencies targeting Linux exclusively. I've written about a few of its development milestones: https://www.matheusmoreira.com/articles/self-contained-lone-... https://www.matheusmoreira.com/articles/delimited-continuati... I'm particularly proud of my ELF hack to allow the interpreter to introspect into a lisp code section at runtime without any /proc/self/exe shenanigans. Wish other languages would adopt it. Top comment and its replies talk about linking the lisp code into a self-contained, easily distributable application: https://news.ycombinator.com/item?id=45989721 I think I addressed that problem adequately. I can create applications by copying the interpreter and patching in some special ELF segments containing lisp modu

> Has anyone else built something similar? I made my own lisp. It used to have a recursive interpreter but I recently finished converting it into a register/stack machine that's essentially a modified version of the Explicit Control Evaluator from Structure and Interpretation of Computer Programs. https://github.com/lone-lang/lone/blob/master/source/lone/li... Now I'm thinking about converting it into a CESK machine which I believe is a proper stack machine. Modifying the SICP machine has proven difficult due to the loose stack discipline. I'm told register machines are faster but keeping track of all those ad hoc pushes and pops is turning into a nightmare. > What features would you add to make it more useful? The neat part about all these machines is how the stack itself turns into some sort of code. You push some state indicating what

> Go binaries on Linux don't need libc (except for NSS, which is glibc-only idiocy). They don't need NSS either, they just chose to depend on it because getting rid of if was too painful. Everyone's addicted to glibc and nobody enjoys going through the withdrawal symptoms. > Running a static libc-less binary as init is fun and easy! It's incredibly fun. I wrote a freestanding Linux Lisp interpreter and my long term goal is to boot Linux into it and bring up the entire system from within the REPL. https://github.com/lone-lang/lone I haven't tested it but I bet Linux can already boot into it just fine. I still need to do more work to make it able to bring up the system though. I've implemented endianness independent memory access functions, now I need a binary structure encoder and decoder. That will enable programs to do kernel I/O properl

I've been working on that language for a while now! https://github.com/lone-lang/lone It's a lisp interpreter with a built in system-call primitive. The plan is to implement everything else from inside the language. Completely freestanding, no libc needed. In the future I expect to be able to boot Linux directly into this thing. Only major feature still needed for kernel support is a binary structure parser for the C structures. I already implemented and tested the primitives for it. I even added support for unaligned memory accesses. Iteration is the only major language feature that's still missing. I'm working on implementing continuations in the interpreter so that I can have elegant Ruby style iteration. This is taking longer than expected. This interpreter can make the Linux kernel load lisp modules before its code even runs. I inven

I learned it from his email to the Python mailing list! https://mail.python.org/pipermail/python-dev/2012-December/1... https://github.com/lone-lang/lone/commit/da13b67a61248b832b2... I didn't know he had done a presentation about it, thank you for posting that video!

I made a lisp that's somewhat close to what you described. It's a freestanding lisp that targets the Linux kernel directly. No libraries, not even libc. https://github.com/lone-lang/lone

> register scanning isn't portable Certainly not but it wasn't particularly hard to implement either, I managed to do it with some simple inline assembly. Here's my programming language's register spilling code: https://github.com/lone-lang/lone/blob/master/architecture/x... https://github.com/lone-lang/lone/blob/master/architecture/a...

It's turned into one of my favorite topics too. It's weird how all the tools out there are all about the ELF sections. Apparently the sections are where all the fun stuff gets stored and the program headers are just some kernel wizardry nobody really cares about. The section/segment dichotomy exists so that kernels need not load needless stuff onto memory. In practice it means things like ELF symbol tables are not available for introspection by the program. If pointers to those symbols are required, the easiest way is to get the ELF interpreter to give them to the program. If it's a static executable then there's no interpreter and things get annoying fast. Most solutions I've seen involve reading the program's own executable into memory and parsing the ELF structures, essentially duplicating the work of the kernel's ELF loader. Alternati

What's wrong with bash though? Targeting bash specifically has massively improved my productivity and decreased the incidence of easily avoidable mistakes. Portable POSIX shell scripting is hell on earth but bash scripting with shellcheck can be surprisingly pleasant. I had the same experience with portable makefiles and GNU Make. For example, I managed to create a surprisingly good test suite with bash and the rest of the GNU coreutils: https://github.com/lone-lang/lone/blob/master/scripts/test.b... It even runs in parallel. Submitted a patch to coreutils to implement the one thing it couldn't test, namely the argv[0] of programs. I should probably go check if they merged it...

Not too long ago, a project of mine was shared here on HN. https://news.ycombinator.com/item?id=38126052 In that thread I wrote: > I have this vision in my mind: embedding lone modules into sections of the lone ELF and shipping it out. Zero dependencies, self-contained. I've been working on that since that day. Proud to say I've gotten it to work and thought I'd make it the subject of my first Show HN. Some free software projects gained features along the way too. The link is to an article with a proper demonstration, technical details and what happened in the past few weeks. The complete repository itself can be found here: https://github.com/lone-lang/lone I've completely reorganized it since the last thread. Would be very happy if you guys tried it out.

Yeah, she actually got that feature standardized. Apparently it's a binary version of the feature used in those self-extracting installer .run scripts. I finished the embedded segment loading feature by the way. I'm writing that article as promised but if you'd like to check it out ahead of time: https://github.com/lone-lang/lone/blob/master/source/tools/l... https://github.com/lone-lang/lone/blob/master/source/lone/au... https://github.com/lone-lang/lone/blob/master/source/lone/se... https://github.com/lone-lang/lone/blob/master/source/lone/mo...