rune v1.5.0

Released alongside Torvik v1.5.0 "The Forge".

Run a single file

rune run script.tv
rune run scan.tv report.csv data.csv

Compiles, runs, cleans up — no binary left behind. Anything after the filename reaches the
program through args() / args_get(i). A bare rune run still builds and runs the project
as before.

Build a kernel

A [build] section turns rune into a build tool for freestanding targets:

[project]
name = mykernel
version = 0.1.0

[build]
target = bare
entry = kernel_main
arch = x86_64-unknown-none-elf
link-script = linker.ld
link-with = boot.s
runner = qemu-system-x86_64 -kernel {output}

rune build      # -> build/mykernel.elf
rune run        # builds, then hands the image to the runner

A bare project builds to .elf rather than the host's executable extension — calling a
kernel mykernel.exe would be a lie. rune run doesn't try to execute it either, because
the host can't; it passes the image to whatever runner names, with {output} replaced by
the built path. Leave runner out and rune builds the image and tells you how to add one.

A link-script or link-with named in the manifest but missing is rune's error, reported
before clang ever runs.

Major versions are opt-in

rune update now keeps you on your current major and reports a new one instead of
installing it — while still pulling the newest release within the major you're on:

Heads up: Torvik v2.0.0 is available - a NEW MAJOR (you're on v1.5.0).
  Staying on 1.x, since a major version can break existing code.
  When ready:  rune update v2 --yes
  Silence this notice:  rune update --silence-major

--silence-major quiets that notice until the next major ships. It refuses if there's
nothing to silence, so a version that hasn't been released can't be muted by accident.

The standard library

std has its own repository and version line as of
Torvik v1.5.0. rune installs and updates it, gated the same way:

std = "1.3.0"        # in torvik.rune

A pin is an explicit instruction and is honoured, including across a major. Without one,
rune keeps std inside its current major and surfaces a new one once. To opt in:

rune update --std-major          # check only - reports, installs nothing
rune update --std-major --yes    # install it, and write the pin for you

With --yes, rune writes std = <version> into your manifest so the project and the
toolchain stay aligned. --silence-std-major quiets that notice.

Changed

• std is fetched from torvik-lang/std rather than from the Torvik repository. Installing an
  older Torvik still works exactly as before — those releases carry std in their own tree,
  and git tags are immutable.
• Silencing a major-version notice when there is no new major now refuses with an explanation
  instead of quietly recording nothing.

Internal

rune has its own test suite (dev/tests/run_tests.sh, 19 cases). It previously lived
inside Torvik's suite, which meant a rune regression could only be caught by building the
compiler. They're separate now — and Torvik's suite runs with only torvc installed.

Install

rune ships with Torvik. To install or update it alone:

# Linux
curl -fsSL https://raw.githubusercontent.com/torvik-lang/rune/main/linux/install.sh | sh

# Windows (PowerShell)
iwr -useb https://raw.githubusercontent.com/torvik-lang/rune/main/windows/install.ps1 | iex

Already installed? rune self-update.