ljsyscall

Yes, exactly. You can even do that from any arbitrary scripting engine that supports executing arbitrary C functions. For example, here, complete access to the linux/bsd/osx system call interface, including sbrk, from lua: https://github.com/justincormack/ljsyscall Just load libffi (https://sourceware.org/libffi) or a similar module in any arbitrary language, and off you go!

I maintain LuaJIT syscall bindings https://github.com/justincormack/ljsyscall - they cover quite a lot, namespaces, netlink and so on. I spent quite a bit of time making them more intuitive than the raw bindings, with consistent error handling, also namespacing constants and so on. It is definitely useful to have these types of interfaces not in C.

https://github.com/justincormack/ljsyscall is just that, but for Lua. FFI to the kernel on Linux, NetBSD Rump kernels and even bare on Xen.

Also my project ljsyscall https://github.com/justincormack/ljsyscall - you can run this on bare metal on Xen and other platforms too as well as under Linux/OSX/BSD.

If you want to explore system calls without C or assembler, I wrote a LuaJIT library [1]. You could port it to another language too. [1] https://github.com/justincormack/ljsyscall

Yes, I have a side project to experiment with scripting the OS with Lua [1] - it has enough functionality to bring up a system (networking, mounts, namespaces etc) without any other code. [1] https://github.com/justincormack/ljsyscall

yeah, you link to lua.a or lua.so and a very small stub to run the code. There is an example here https://github.com/justincormack/ljsyscall/blob/master/examp...

Been working on Lua based stuff that can bring up enough of a system for containers (networking and so on, still some bits missing) https://github.com/justincormack/ljsyscall

My side project ljsyscall [1] is a LuaJIT wrapper for the system call and other kernel APIs (eg netlink to configure networking). Its not really designed as a shell per se (although you can use it like that), but it is designed to expose Lua data structures for the output of stuff - ls will return an iterator, network interfaces are hash tables and you can modify the components to reconfigure etc. [1] https://github.com/justincormack/ljsyscall

Yeah have been working on it see https://github.com/justincormack/ljsyscall/

Working on a scripting interface to Linux designed so you can configure everything internally to your application (ie it can run as the init process) with no significant dependencies (you can statically link it)[1]. Its not finished yet, but you can configure network interfaces, routing etc. Needs some more examples, build scripts etc... [1] https://github.com/justincormack/ljsyscall

I have been experimenting along these lines, by making a scripting interface to Linux that lets you do the basic stuff that you need to bring up a VM/container/hardware [1], This includes bringing up networks, configuring addresses and routing. There is a lot to do (still need iptables), but you end up with a script over Linux that configures it, using a scripting language and ffi, which you can compile into a single binary and eg run as your init process. Linux is a pretty decent API if you wrap some scripting around it rather than a lot of C libraries and shell scripts. You do not of course end up with a standardised interface from this, as it is dependent on the Linux environment you are running in (although a VM can standardise this). So I am also experimenting with userspace OS components, like the NetBSD rump kernel [2] in the same

Yes I thought the kernel API did not look too hard to use; FUSE support is no the TODO list for ljsyscall[1] which is a LuaJIT implementation of the Linux (and partially OSX, NetBSD) kernel API. Implementing against native kernel APIs in a scripting language with an ffi is manageable although the interfaces are large; Go seems to be about the only language that has a real effort to do this, other than my project (do have longer term plans to port to Ruby, Pypy one day once it is abstracted out more). [1] https://github.com/justincormack/ljsyscall

I see they say they can't use the ffi [1] as libc is not in the initrd which is kind of unfortunate as it makes it a lot more work. Issue is that glibc is insanely big for an initrd. For my similar project based on LuaJIT [2] I use the ffi and Musl libc [3] which is a sane sub 600k shared library (all in one file). Will put up a bootable system soon. [1] http://git.savannah.gnu.org/cgit/guix.git/tree/gnu/packages/... [2] https://github.com/justincormack/ljsyscall [3] http://www.musl-libc.org/