what is ix?

a computer in the cloud, billed per second for the cpu, memory, and disk it actually uses. you never pick an instance size. the whole machine is declared with nix, or just booted and used, nothing declared at all.

pricing

the vm scales itself, so headroom costs nothing: you pay for what the machine is using, not what you reserved. drag the bars and watch the price.

agent-vm-42 drag bars to adjust

CPU ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ / 64 vCPUMEM █▉░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ / 256 GiBDISK ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ GiB / 1 PiB

$0.000008/s × 0.01 vCPU $0.000000/s$0.000003/s × 0.5 GiB $0.000001/s$0.000002/s × 1 GiB $0.000000/s

TOTAL █▏░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ $0.000001/s

boot a machine, now

install the cli

$curl https://ix.dev | sh

the reference comes with it: man ix, or man ix-<command> for one.

one command boots a fresh machine and drops you into its shell:

$ix new

the machine stays up after you disconnect and keeps its files until you remove it. run bare ix to open the dashboard: every machine you own, live cpu and memory, shell and logs one keypress away.

bare ix new boots the base: a full nixos with the usual tools, the default template. give it a flake ref to boot any other.

any repo whose flake evaluates to a nixos system boots the same way - built once, cached, #name picking the configuration:

$ix new github:indexable-inc/index#<service>

make it a project

nothing remembers how you set that first machine up. when it should outlive your shell history, put it in a repo:

$mkdir app && cd app && git init

$ix initcreated default.ix

$ix applycreated flake.nix

default.ix declares the machine: every package, service, and open port in one file that splits into modules as it grows. syntax is javascript, semantics are nix. ix apply makes the machine match the config, every time: edit, re-apply, converge. the first apply also writes flake.nix, pinning exactly what your machine builds from.

app/

// JavaScript syntax, Nix semantics. One VM; `ix apply` builds and
// activates it. The scaffold starts with one inline module; this project
// has grown into files.
export default ({ index }) => ({
  modules: [
    import("./modules/tools.ix"),
    import("./modules/web.ix"),
  ],
});

the world of ix

underneath, ix is two primitives: machines that autoscale, and the virtual ethernet that wires them to each other and to the internet. everything above that - firewall to web server - is open source and lives in the index: one monorepo of build recipes, all prebuilt and kept current, so your machine downloads finished software.

snapshots

a snapshot is the whole machine at one moment: disk and memory, frozen. take one before risky work; restore it into a new machine; fork several machines from the same point.

$ix snapshot app$ix new <snapshot-id>

the machine, running. ix snapshot app freezes this moment.

current limitations

one vm grows to 64 vcpu, 256 GiB of memory, and 1 PiB of storage.