MirageOS Blog

There are actually a great many efforts in this regard. You mention Freedom box and Sandstorm, which are only two of them. I'm working on http://nymote.org and it'll be built using Unikernels (specifically, Mirage OS - http://openmirage.org). Targeting the home router is something we've been working on for some time but the work stretches from deep tech to human-computer interaction. Most of this work is in academia for now but as soon as there are business models that work, we expect to see real deployments (beyond the hobbyists).

They're of course not a desktop option at all, but there's also some very interesting work happening with unikernels, which are really only recently a viable option now that Xen can present a unified hardware layer, instead of the endless treadmill of specific drivers. I've been getting into OpenMirage [1] quite a bit recently, largely due to the energy of the team [2], but also looked a bit at HalVM [3]. I definitely recommend [2] for anyone interested in plausible ideas of what the one of the next generations of VM/apps might look like. [1] http://www.openmirage.org/ [2] https://www.youtube.com/watch?v=UjonFD-2ATo or http://www.se-radio.net/2014/05/episode-204-anil-madhavapeddy-on-the-m… (audio only) [3] https://github.com/GaloisInc/HaLVM

OCaml works great for systems programming (its runtime is orders of magnitude simpler than F# and the CLR). See http://openmirage.org for a bunch of libraries that may be of use to you, such as TCP/IP in OCaml (or https://github.com/mirage)

If you're looking for a reason to learn OCaml, Xen recently announced the 1.0 release of the MirageOS unikernel[1]. Basically you write your application in OCaml and it's compiled directly into the kernel, with the goal of eliminating a lot of the overhead from using a general purpose OS by doing only what your application needs. It's a very cool concept which I think has been a long time coming. The best part is that you can easily run the compiled unikernels on EC2 (and any other cloud provider which allows you to run a custom kernel). http://www.openmirage.org/

I read three books at a time, and only pick up/start/buy a new one once I finish one. Helps acquiring a large back log of unread literature around the apartment. :) * Labyrinths - Jorge Louis Borges [0] I believe HN was the reason I picked this up, if I remember correctly. It's a collection of short stories, each of which can be finished in a night, which is satisfying. I really dig his writing style and fantastical nature of the stories. I've done a bit of philosophical reading but a lot of the references he makes go over my head, leaving me to do a bit of research after each story. * The Design of Everyday Things - Don Norman [1] Picked this up after finishing Debbie Millman's How to Think Like a Great Graphic Designer [2] (Misleading title, I would 100% recommend this book to anyone). I'm not sure what I expected, but so far this hasn't been satisfying. The first couple of chapters have been laying out a framework and defining terms. Considering swapping this out for Jon Kolko's Well Designed - How to Use Empathy To Create Products People Love [3], which seemed much more actionable after picking it up at Barnes and Noble. * Real World OCaml - Yaron Minsky, Anil Madhavapeddy, Jason Hickey [4] Second time picking this up, originally read up to chapter on Functors over the summer. I started over this time and I'm about finished with the first section, "Language Concepts", now. It's worth noting that the entire text is available online for free on the book's…

If you find this interesting you may want to read about this more current research: http://www.openmirage.org/ To quote from the vision paper http://anil.recoil.org/papers/2010-bcs-visions.pdf Mirage is written in the spirit of vertical operating systems such as Nemesis [17] or Exokernel [10], but differs in certain aspects: (i) apart from a small runtime, the operating system and support code (e.g., threading) is entirely written in OCaml; and (ii) is statically specialised at compile-time by assembling only required components (e.g., a read-only file system which fits into memory will be directly linked in as an immutable data structure). These features mean that it provides a stronger basis for the practical application of formal methods such as model checking; and the removal of redundant safety system checks greatly improves the energy efficiency of the system.

I think the problem is that operating systems aren't that useful until they have applications and a userbase. Some projects (like Mirage[1] and a few others) try to get around this by building on top of Xen, but that creates a lot of friction. [1]: http://openmirage.org/

I read F# Weekly every week, just to keep in the loop about what's happening with F#: https://sergeytihon.wordpress.com/category/f-weekly/ That's probably the only programming blog I regularly check, though I return to Open Mirage every now and again to see how they're getting on: http://www.openmirage.org/

I have started playing with Rust and have used OCaml on and off, but recently really diving hard into it building a REST-based application from top to bottom in OCaml, including all the infrastructure bits. We are slowly making our stuff open source as it becomes useable: https://github.com/afiniate In short, OCaml is a mature language that has been used for decades in commercial applications. I feel OCaml is the next progression for the people that got excited about distributed systems via the Erlang path and want more of the safety and reasoning that comes from a strongly/statically-typed language like OCaml. Rust may or may not take off, but I am confident OCaml will remain viable for the foreseeable future, and probably gain slow, but steady popularity as engineers see all the cool things you can do like MirageOS: http://openmirage.org/

Also relevant: http://openmirage.org and https://www.youtube.com/watch?v=bYQ_lq5dcvM

No wonder OCaml compiled to native is faster than other MLs and Python. I rem stumbling on benchmarks elsewhere, where compiled OCaml rivaled CPP in terms of performance on certain tests. In my experience with OCaml, I have found the syntax a bit too unfavourable like the author did, but the resulting code was very fast. With concurrency sorted out, I wonder if it could take on Rust, Nim, and Go as far as systems-programming is concerned (esp since Go has the weight of Google behind it). It also helps that the language designers have written a large tutorial on systems programming: https://ocaml.github.io/ocamlunix/ Then there's this epic Mirage OS built with Cloud Computing in mind by Anil and his team of OCaml zealots: http://openmirage.org/

Interesting, reminds me of HaLVM (Haskell on Xen) and Mirage OS (OCaml): - https://github.com/galoisinc/halvm - http://www.openmirage.org/

See also https://github.com/galoisinc/halvm and http://openmirage.org

MirageOS? (http://openmirage.org/) I kid, but only a little.

I think running linux containers without linux would be difficult! You probably want Mirage OS or OSv. http://www.openmirage.org/ http://osv.io/

Some people wrote a completly new TLS Stack in Ocaml to combat this problem: http://openmirage.org/blog/introducing-ocaml-tls Here a Video about Mirage OS and this TLS Stack from the 31C3. Trustworthy secure modular operating system engineering - http://media.ccc.de/browse/congress/2014/31c3_-_6443_-_en_-_saal_2_-_2… There goal is to reduce the trusted computing base to a minimal. Rust could deliver some of the same benefits to writing highperformance low level code.

This article [1] lists a couple of other "cloud OS" systems. OSv and mirage [2] seem to be the two most promising ones right now. 1: http://www.linux.com/news/enterprise/cloud-computing/751156-are-cloud-… 2: http://www.openmirage.org/

Sounds a bit like Mirage OS to me (http://www.openmirage.org).

You might consider Mirage OS (http://www.openmirage.org/) to be systems programming.

Yes, I fully understand and agree with all of that. However, I think it is still not accurate to say that apps run operating systems. More accurate to say that apps embed operating systems or are themselves bundled with operating systems (such that they can run on bare metal). And, MirageOS (http://www.openmirage.org/) takes this concept to its logical conclusion.

Worth a look: irmin, http://openmirage.org/blog/introducing-irmin plan9, https://www.cs.unm.edu/~fastos/05meeting/PLAN9NOTDEADYET.pdf

Any plans to support Xen? Then one could run Mirage unikernels (http://openmirage.org/) ...

I thought they wouldn't want to muddle the waters by saying "microvm" instead of just using the term container. I thought they were using something like Mirage: http://openmirage.org/ Which, imo, would be more exciting.

Makes me think about the conceptual split between OS and languages, and how much it's needed. About bare metal language hosting, http://www.openmirage.org/ comes to mind, sure it's not smalltalk or even a lispos but that's still a big step in bare metal abstraction running.

There are a few people who are doing that. One good example is the work that Anil Madhavapeddy's been doing on the Mirage OS: http://www.openmirage.org/ It's a really impressive use of OCaml. Not sure why there are so few other good examples to point to though.

Maybe it's b possible to port a database to a model like OpenMirage's [1], building against all the runtime it requires but running on top of a hypervisor? [1] http://www.openmirage.org/

Since there has been a resurgence of interest in OCaml on HN, some may be curious to see how a production quality Btree implementation looks like in OCaml. Algebraic data types, make it particularly convenient for these sorts of things. For comparison one may contrast it with an implementation in a language that does not have algebraic types, C++ for example. So glad Rust chose to have them. Here is a Btree implementation from the mirage project [1] https://github.com/cgreenhalgh/ocaml-btree/blob/master/lib/btree.ml EDIT: removed link to binary tree after kerneis pointed it out. [1] http://www.openmirage.org/

If ocaml is a language waiting for a killer app, this might be it: http://www.openmirage.org/ There was a presentation at the FP eXchange in London last Friday about mirage and many a mind was blown!

An implementation of the idea: http://www.openmirage.org/ A good talk about it by one of the developers/researchers: http://vimeo.com/16189862

Although OS research is being done with OCaml by Xen Foundation and Cisco http://www.openmirage.org/