An evolving language and systems project

Build systems with their rules in the open.

Sash is a programming language and ecosystem in active development. Product behavior is being moved into Sash itself, with explicit boundaries where a platform must provide services.

Current maturity: work in progress. The compiler and operating-system experience are not yet complete products.

SASH
source
runtime
host contract
In progressPure-Sash compiler
Local previewSashOS experience
Not availableLive Sasha inference

01 / The project

One language at the center.
Clear limits around it.

Sash aims to make language, reusable libraries, agent behavior, and SashOS product logic readable and reviewable in Sash. Bootstrap and platform adapters support that goal; they are not substitutes for the canonical implementation.

A

Sash is canonical

Reusable language and agent behavior belongs in sash-libs/; SashOS product behavior belongs in sashos/os/.

Read the working repository
B

Bootstraps stay distinct

The existing JavaScript bootstrap is a separately scoped path. It must not depend on or launch a Rust executable.

Explore the bootstrap repository
C

Effects cross a contract

Filesystem, storage, and platform effects pass through documented host capabilities rather than ambient access.

Explore SashOS support

02 / How the pieces connect

Source to experience,
without hiding the seams.

The repository is a work-in-progress integration. These boundaries describe ownership and intended flow, not a claim that every target is finished or interchangeable today.

01Sash sourceLanguage and product modules
02Compiler stagesFront end, IR, and targets
03RuntimeDeclared bootstrap paths
04Host ABIExplicit platform services
05SashOSServices, screens, and shell

A host boundary is not a security guarantee by itself. Workload isolation, authentication, and platform support must be evaluated and accepted separately for each deployment.

03 / Evidence, not hype

What exists today.

These are deliberately bounded snapshots. See the project documentation for the exact support matrix and evidence attached to a specific source revision.

Active01

Language and bootstrap

A JavaScript seed bootstrap, compiler foundations, and SashOS-on-WASM experiments exist. The supported language surface is bounded; this is not yet a complete self-hosted toolchain.

Sash libraries and compiler work
Preview02

SashOS desktop

The checked-in local preview has a graphical browser Desktop and a VS Code experience. Current browser capabilities remain limited and device-local-first.

Visit the SashOS site
Limited03

Sasha and apps

Sasha's current screen is routing-oriented, not live model inference. App installation and execution are also bounded; a full app lifecycle is not accepted yet.

Review current project state

04 / The operating-system project

SashOS is a preview,
not a production service.

The first hosted web direction is a local-first PWA. User state stays in the browser in this phase. GitHub sign-in and encrypted backup/sync are intentionally later work, not an implied feature.

Explore SashOS No account or remote user-data store is required for the local-first preview.

05 / What comes next

Build the foundations
before widening the promise.

Progress is gated by working vertical slices and repeatable evidence—not by a feature's presence in a plan or repository.

  1. NowCurrent preview

    Make the local-first browser experience dependable

    Package the SashOS source and browser host with explicit capability reporting, offline behavior, and clear recovery.

  2. NextRuntime foundations

    Expand the shared, tested language surface

    Improve the pure-Sash compiler/runtime path and keep bootstrap behavior aligned through conformance tests.

  3. LaterSecurity and accounts

    Design remote capabilities only after the boundary is ready

    GitHub login, encrypted private backups, multi-device restore, and any remote service require a separate threat model and explicit consent.

A promise we can keep

In development means
in development.

  • No claim of a complete, self-hosted compiler.
  • No claim of an isolated workload sandbox.
  • No claim of live Sasha model inference.
  • No claim of production multi-user readiness.