The language borrows syntax from Python (and a wee bit from Haskell) and is essentially syntactic sugar over facilities provided by the runtime:

- statically typed from end to end

- closed and open/extensible types

- closed types are immutable, open ones have two variants: immutable and mutable

- arrays have two variants: immutable and mutable

- no OOP/classes. inheritance is nominal and mainly exists to provide access to class membership (is X a Y?)

- functions operating on data

- UFCS exists to provide nice features like "apple".substr(...)

- first class functions and closures

- monomorphized generics

- tailcalls

- operator overloading

- modules and namespaces to control access

- erlang/beam style first class processes. So you `spawn` a function and communicate between processes using send/recv instead of async/await

Processes are completely isolated at the runtime level. Each has its own stack, heap, mailbox and GC.

The bytecode carries all type information. The VM will compile using AOT-on-load.

My own runtime-becomes-a-os idea is still just an idea. I haven't really pursued it with seriousness. Will probably do that once the language and runtime stabilize.

It sounds like you already have a pretty complete OS; you just don't have it running on bare metal (or on a hypervisor) yet. I hope I get a chance to see the language someday!