binsquare

Building a replacement for docker focused on better isolation and more lightweight resource utilization.

It's a sandbox that you can embed ala the sqlite of VM's.

Link: https://github.com/smol-machines/smolvm

A manager might say you need to stop waking up.

For the layman, I was looking for data on correctness.

I found `This is measured agreement, not a promise of universal bitwise equivalence` which seems to me a bit wishy washy

They're all bad, some are worse

We should have enough distaste for them all

I do not think we should trust this harnesses claims.

There's so much fluff because it doesn't care about what the user actually cares about.

So there's the usual structure of "it's not x it's actually y" signs.

What are you trying to do?

Docker shares the host kernel + networking stack, so container traffic goes through the host's iptables. So if you're running into some weirdness because of that, happy to help if you can share your setup details.

disclosure: dealt with container weirdness for last 5 years, nothing to sell.

smol machines: https://github.com/smol-machines/smolvm

slim, fast, microvm that runs on every platform.

disclaimer: am author

smolvm has better bootup time (<200ms), secrets handling, and egress control compared to lima. Among other things like native branching/forking of the vm itself.

As for the rug pull concern, I'm committed to open source with 2 pieces of evidence.

1. oss license 2. Business model is accruing revenue from offering hosted service + inbound due to the open source project. The business model + open source is aligned.

disclaimer: maintainer of smol machines

Easily at scale

Size is not a good indicator for content quality

I've been personally using this and it's greatly improved testing and finding edge cases

Use smolvm, support for tailscale in each VM.

https://github.com/smol-machines/smolvm

I tried this because I started hitting the GitHub actions limit for my private registries and found my 5yr old hardware is easily 2x faster than whatever hardware I was paying GitHub for.

From the perspective of user empathy, wsl seems to be designed for that use case. but the implementation/defaults can be improved

Lot of the WSL2 lag is not the VM itself, it's the 9P file sharing and interop.

I found that seems like anything under /mnt/c goes through 9P

Cert pinning: not a problem. we don't decrypt traffic, we just pass it through. The only exception is hosts you give a credential to, since we have to insert the key.

Memorized IP: doesn't work, the vm can only connect to an IP if it came from a DNS lookup of an allowed name. Any other IP is blocked.

A bit of "shared responsibility" philosophy kicking through but I try to have good defaults

thanks

I'd also add that MXC is still sharing the host kernel.

i.e. on mac MXC uses seatbelt, so the agent shares your kernel.

but smolvm gives each task its own VM with its own kernel, same on mac, linux and windows. + additional layers like preconfigured seccomp, landlock, wherever it makes sense

love seeing preloop's work :)

hey simon,

smol machines actually support exactly those things across macs,linux, windows btw: https://github.com/smol-machines/smolvm/blob/main/AGENTS.md#...

here's a snippet of how it looks like to configure that:

  [network]
  allow_hosts         = ["api.github.com"]          # hostname, also allows its subdomains
  allow_host_patterns = ["example.com", "*.npmjs.org"]  # exact names, or *. for subdomains only
  allow_cidrs         = ["10.0.0.0/8", "1.1.1.1"]  # IP ranges  or single IPs

  [[network.credentials]]
  name                 = "github"
  environment_variable = "GITHUB_TOKEN"

I like that this is a very opinionated approach to interfacing with agents

It reads to me like chasing trends

I think ai certainly raises the bar for those with taste

I'm going to toss in smolvm as well because firecracker needs some expertise to make the box usable and secure.

https://github.com/smol-machines/smolvm

thanks! author of smolvm here.

I focus on being the batteries-included approach for microVMs. So network is off by default, and you can allow specific hosts (DNS is filtered too), so an agent can reach its model API and nothing else.

And then I also put a lot of work in the jailer-style hardening around the VMM process itself: seccomp allowlist, Landlock, separate unprivileged uid per VM, and cgroup limits.

So that users have security & knobs right out of the box.

fwiw i used to operate an AWS service using firecracker.

The shared kernel/lack of isolation between the cotnainer workloads is the model that this article isn't really touching but is really important.

Because the current needs are extremely lightweight and isolated environments i.e. vm per workload rather than shared.

And there's been a lot of wonderful innovations happen there

I'm glad that Newgrounds is one of those sites that has kept it's soul all these years.

Even the same old games are still there

it used to just be a upscaling, but now it completely changes the artstyle.

I'll keep it going just for you

Libkrun and firecracker had similar foundations (Rust, KVM, rust-vmm).

Firecracker has a long track record but has a lot of knobs and tunings to get the security right.

smolvm's serve mode confines each VMM by default with a seccomp allowlist, Landlock, a per-VM uid and no_new_privs, much like Firecracker's jailer.

For dangerous workloads, people can do the same things such as skip host mounts and use virtio-net.

It's not a different security class just because it's libkrun vs firecracker

yes, separate kernels + virtualized hardware via hypervisor.

containers are built on linux primitives & so shares the kernel.