install
system module install
<img align="right" src="https://github.com/mearvk/SLeeLa/blob/master/images/debian/debian-logo.png" width="75" height="75" alt="SLeeLa">
SLeeLa Quick and Safe Install
The installer supports user-local and system-wide installation on Linux, macOS, and Windows 10+. User-local installation is the recommended default and does not require administrator access.
Clean Install (recommended for most users)
For a calm, beautiful, guided install of the main package only, run:
make clean-install # auto-selects the host platform; or run directly:
./install/sleela-clean-install.sh # Linux
bash ./install/sleela-clean-install-macos.sh # macOS (bash 3.2-safe)
install\\sleela-clean-install.cmd # Windows 10+ (PowerShell launcher)
make clean-install and the make build → advanced-build prompt dispatch by host OS.
The macOS script is Bash 3.2-compatible. Windows uses native PowerShell and requires
native MinGW-w64 toolchain and Python 3. The PowerShell installer invokes
build-windows.ps1 for a native build; with -NoBuild, it requires the
existing impl/build/sleela.exe, sleelvac.exe, and nordshrift.exe
artifacts and will not relabel non-Windows binaries as .exe. All three
scripts share the same guided, block-by-block module selection and verify the
staged integrity manifest before deployment.
It installs the binaries (sleela, sleelvac, nordshrift), the standard
library, protocols, and support modules — and excludes servers, IDEs/editors,
Wi-Fi implementations, and religious/moral/political systems. You make one
primary decision (install the main package), choose a scope, and then — on
success — may optionally add curated enhancement modules (audio, video,
signal-processing, codecs, compression, gui, ui, database, connector).
After the four module blocks, the installer offers a fifth block of top-level
programs — stand-alone subsystems that live as their own top-level directories
rather than lib/ packages, so they are selected and staged explicitly:
pi-generator— the SLeeLa Pi spigot program that streams digits to a file.artificial-intelligence— the AI subsystem:large-language-models(RRS / RLM, code LLMs, parametry, the RRS signal monitor),neural-nets,character-recognition, andrrs.
The block defaults to yes (include all); decline it to choose each program individually, or they are all pulled in by the "install EVERYTHING" fast path.
After the module blocks, the installer also offers the SleelaTerminal — the
original GUI terminal and slsh shell (a separate C++ component under
sleela-terminal/, not a lib/ package). Answer yes and it is built and
copied into the same scope you chose: for a user-local install into your
user directory ($INSTALL_ROOT/bin, with its assets/), or for a system
install into the system directories under /usr/local (binaries in
/usr/local/bin, assets in /usr/local/bin/assets, and a .desktop entry).
The GUI needs GTK4 + VTE development packages (gtk4 and vte-2.91-gtk4); when
they are not present the installer still installs the slsh shell and skips the
GUI binary with a clear note, so the choice always yields a usable terminal.
Declining leaves the main package untouched. (On Windows, the .cmd/PowerShell
installer does not build this Unix GUI component.)
The output is styled with the SLeeLa palette and degrades to plain text
automatically when not attached to a terminal, when NO_COLOR is set, or with
--plain. The full-featured installer below (with server/HTTP/VM-edition
options) remains available for advanced deployments.
Installation scope
At the start, choose:
- User-local (recommended): Linux/macOS default
$HOME/.local/sleela; Windows default%LOCALAPPDATA%\\SLeeLa. The installer places compiled executables in the installation'sbin/directory and can configure only the current user's PATH. On Windows, the runtime support tree is%LOCALAPPDATA%\\SLeeLa\\lib\\sleela, matching the executable-relative runtime lookup. - System-wide: Linux/macOS default runtime root
/usr/local/lib/sleela, executables exposed through/usr/local/bin, and startup configuration in/etc/sleela/startup.conf. The installer usessudofor privileged writes. Windows default is%ProgramFiles%\\SLeeLa, requires an elevated PowerShell, and adds the install'sbin/directory to the machine PATH. Its runtime support tree is%ProgramFiles%\\SLeeLa\\lib\\sleela.
The Linux/macOS user-local destination can be overridden with SLEELA_INSTALL_ROOT; system runtime root can be overridden with SLEELA_SYSTEM_ROOT. On Windows, pass -Destination to choose the destination explicitly.
Installation flow
- Choose user-local or system-wide scope.
- Select SLeeLa System/server, HTTP servers 1–9, VM edition, and Port Authority startup options.
- Build SLeeLa before deployment unless the Windows
-NoBuildoption is used. - Stage the runtime, including the compiled
sleela,sleelvac, andnordshriftproducts. - Back up an existing destination before updating it.
- Install binaries, libraries, and
config/startup.conf. - Configure only the PATH scope corresponding to the selected installation mode.
- Report the installation and configuration locations.
A missing compiled product or failed build stops installation before deployment.
Platform entry points
- Linux:
./install/quick-safe-install.sh - macOS:
./install/quick-safe-install-macos.sh - Windows 10+:
install\\quick-safe-install.cmdorinstall\\quick-safe-install.ps1
Native Drive installation
The runtime staging steps include the Native Drive helpers
tools/sleela-native-drive.py and tools/sleela-native-service.py alongside
the SLeeLa control plane. Both scripts are included in the trusted SHA-256
manifest and are copied into the installed runtime's tools/ directory by
the conventional, POSIX quick-safe, and Windows quick-safe installers.
Python 3 is required to invoke Native Drive through sleelactl.
After installation, use sleelactl info native-drive to confirm the registered
tool and sleelactl inspect native-drive service --help for the service
generator's options. Service installation, enabling, and starting remain
explicit operator actions.
Safety model
- User-local mode never elevates privileges or changes the machine PATH.
- System-wide mode explicitly requests administrator privileges and uses conventional system paths.
- Build failure stops deployment. Existing destination files are backed up before replacement.
- System-wide PATH is not changed on Linux/macOS because
/usr/local/binis the conventional executable location;/etc/profile.d/sleela.shsetsSLEELA_HOME. Windows system-wide mode adds its binary directory to the machine PATH.
Commands
make install-help
make install-check
make install-local # user-local, never uses sudo
make install-system # system-wide, uses sudo (system paths only)
./install/system-install.sh # the sudo system installer directly
./install/quick-safe-install.sh
./install/quick-safe-install-macos.sh
install\\quick-safe-install.cmd
User-local vs system-wide, and sudo
The two scopes are deliberately separated so a user-local install never has any reason to elevate:
make install-localinstalls for the current user and never usessudo. With noPREFIXgiven it installs to both conventional user-local layouts, creating any missing directories on first install and requiring no environment variables:$HOME/.local(FHS-style:$HOME/.local/bin,$HOME/.local/lib/sleela, …)$HOME/.local/sleela(self-contained:$HOME/.local/sleela/bin, …)
Passing an explicit
PREFIX=...installs to that single prefix only. It refuses a system prefix (pointing you atinstall-system) and refuses to run as root.make install-systemperforms the system-wide install throughsystem-install.sh. It runs the integrity step as the invoking (unprivileged) user first, then usessudoonly for the privileged copy into system locations.make installis interactive: on a terminal it asks you to choose 1) Local or 2) System, then dispatches toinstall-localorinstall-systemaccordingly. For a system install it prompts for the sudo password as needed (sudo is used only to copy into system locations). Answer without a prompt viaSLEELA_INSTALL_SCOPE=local|system(or1|2). With no terminal and noSLEELA_INSTALL_SCOPEit falls back to the prior scope-aware behavior (a user-localPREFIXstays local; a systemPREFIXwith noDESTDIRelevates automatically; an explicitPREFIX=/DESTDIRstaged build installs to that single prefix), so CI and packaging are unchanged.make install-allrefreshes every standard SLeeLa location in one command, so a single run updates all the directorieswhereis sleelareports. Run it as your normal user (it invokessudoitself for system paths). It performs, in order:- the user-local dual install (
$HOME/.localand$HOME/.local/sleela); - the system install at
/usr/local(sudo, system paths only); - an in-place refresh of any
sleela/sleelvac/nordshriftalready present inEXTRA_BINDIRS(default/usr/bin) so stray copies never go stale. It never creates a new stray command — it only overwrites one that already exists. Override the set withEXTRA_BINDIRS="/usr/bin /opt/bin".
After the three library steps,
make install-allalso builds the standalone SleelaTerminal (GUI +slsh) once and installs it into the same set of locations — both user-local layouts and/usr/local— matching the clean installer. The GUI needs GTK4 + VTE; when absent, theslshshell is installed and the GUI is skipped with a note. SetSLEELA_WITH_TERMINAL=noto skip the terminal; a terminal build/install failure never aborts the run.install-allanduninstall-allresolve the invoking user's home via$SUDO_USERwhen elevated, so the$HOME/.locallayouts are found whether you run them as the user or undersudo.If a location already holds an untracked SLeeLa install (binaries but no
.sleela-install-manifest.json— e.g. one left byquick-safe-install.sh), a plain per-prefix install refuses to clobber it.install-allpassesSLEELA_INSTALL_FORCE=1so it adopts such an install — overwrites the binaries and starts tracking it — instead of aborting. You can setSLEELA_INSTALL_FORCE=1yourself on a single-prefixinstall/do-installto get the same adopt-and-overwrite behavior.- the user-local dual install (
make uninstall-allis the mirror ofinstall-all: it removes the tracked SLeeLa install from every standard location — the user-local dual layout ($HOME/.localand$HOME/.local/sleela), the/usr/localsystem prefix, and any stray binaries inEXTRA_BINDIRS— skipping any location that has no tracked install. Prefer it over plainuninstallwhen SLeeLa is installed in more than one place. (Plainmake uninstallremoves a single prefix only, which is why it can leave copies behind in other locations.)
Base-code integrity prompt on every install
Before any install variant copies files, it offers to (re)generate and verify
the base SLeeLa code SHA-256 manifest — the integrity baseline the runtime's
execution gate checks against — as a plain yes/no prompt:
- yes — regenerate the manifest from the current source tree, then verify.
- no — keep the committed manifest and verify the tree against it.
- skip — do neither for this install.
Answer non-interactively (CI, package builds) with
SLEELA_MANIFEST_CONSENT=yes|no|skip. When no terminal is attached and the
variable is unset, the step is skipped safely.
How installed commands find their libraries (standard resolution)
You are expected to run the installed sleela/sleelvac, not the copy in a
git checkout. An installed command finds its support files from the install
location, derived from the command's own path, so it works from any working
directory and without setting environment variables:
- command:
<prefix>/bin/sleela - runtime root:
<prefix>/lib/sleela— holds thelib/source-library tree, thesecurity/sha256-manifest.jsonintegrity manifest, thetools/verify-before-execution.pygate, andSHEET.sheet.
Resolution order for each resource (first match wins):
- the matching environment variable, if set —
SLEELA_LIB(library tree),SLEELA_SHEET(catalog),SLEELA_HOME/SLEELA_SHA256_MANIFEST(verify gate) — these remain available as explicit overrides; - the installed runtime root derived from the executable's own location
(
<prefix>/bin→<prefix>/lib/sleela); - the SLeeLa root found by searching upward from the current directory — this is what lets a developer run the build-tree binary from inside the checkout.
So after make install / make install-system, running sleela run foo.sleela
from anywhere resolves /lib, the manifest, and the catalog from
<prefix>/lib/sleela — not from the clone, and not from the current directory.
The clone is only used when you run the uninstalled build-tree binary.
Reinstall safety: existing files are backed up, not clobbered
A reinstall over an existing install first snapshots the previous binaries
and the runtime/data trees into a timestamped directory beside the runtime tree
(<prefix>/lib/sleela-backups/<YYYYmmdd-HHMMSS>/) before writing the new files.
Old files are retained there and never removed automatically — delete a
snapshot yourself when you no longer need the rollback. The install tracker does
not record the backups, so make uninstall leaves them in place. (Override the
location with BACKUP_ROOT=...; staged DESTDIR package builds skip the backup
because they target a fresh package root, not a live system.) The installer also
still refuses to overwrite same-named commands that are not tracked as a SLeeLa
install.
What sudo does and does not touch
When make install-system (or a system-scoped make install) elevates, sudo
is used only to copy SLeeLa into system locations as the trusted system
account. The install:
- does not change the owner, group, or permissions of files you already own;
- does not modify anything in your home directory;
- only writes new files under the system prefix, owned by the system account
(root), as is conventional for
/usr/local.
A confirming privilege note is printed at the end of a system install.
SLeeLa — MEARVK LLC — 2026
Conventional make install
The conventional installation target is non-interactive and installs the built
native commands (sleela, sleelvac, and nordshrift) plus runtime libraries, verification tooling, documentation,
examples, and a default configuration. It does not replace the interactive
Quick and Safe installer above.
From the repository root:
make -C impl all
make install-local # user-local; NEVER uses sudo (defaults PREFIX=$HOME/.local)
make install-system # system-wide; uses sudo for system paths only
make install # scope-aware: local prefix stays local, system prefix elevates
make install PREFIX="$HOME/.local" # user-local; stays as current user
make install DESTDIR="$PWD/package-root" # staged package installation
make install SLEELA_MANIFEST_CONSENT=no # answer the SHA-256 manifest prompt non-interactively
make install-check # verify installer entry points
make uninstall # remove tracked executables/runtime; preserve config
make uninstall PREFIX="$HOME/.local" # remove a tracked user-local install
make -C install uninstall # lower-level equivalent
Privilege handling is scope-aware and split into two explicit targets so the user-local path never elevates:
make install-localinstalls for the current user and never usessudo(it refuses a system prefix and refuses to run as root).make install-systemruns the dedicated sudo installer and elevates only for the privileged copy into system locations.make installkeeps the automatic behavior: a system prefix with an emptyDESTDIRrequestssudofor system paths only; a user-local prefix such asPREFIX="$HOME/.local"runs as the current user and does not elevate; stagedDESTDIRinstalls never elevate.
Every variant first offers the base-code SHA-256 manifest step (yes/no);
SLEELA_MANIFEST_CONSENT=yes|no|skip answers it without a terminal. When a
system install elevates, sudo only copies new files into the system prefix as
the trusted system account — it never re-owns or alters files you already own,
and never touches your home directory. Avoid running sudo make install with a
user-home prefix; use make install-local as the target user instead.
The default executable directory is $(PREFIX)/bin, runtime support files are
under $(PREFIX)/lib/sleela, and shared documentation/examples are under
$(PREFIX)/share/sleela. The default configuration is
/etc/sleela/startup.conf for the default /usr/local prefix. For a custom
prefix, configuration defaults to $HOME/.config/sleela/startup.conf, so a
user-local install does not need root privileges. An existing configuration
is never overwritten. Use BINDIR, LIBDIR, DATADIR, and SYSCONFDIR to
override the corresponding destinations. On Linux, /usr/local/bin is preferred to
/usr/bin for a source installation so system package-manager files are not
overwritten. The uninstall target removes the three tracked executables (sleela, sleelvac, and nordshrift) and the tracked runtime/shared-data files for the selected prefix. It preserves configuration and refuses to remove untracked same-named binaries. Use the same PREFIX, BINDIR, LIBDIR, DATADIR, SYSCONFDIR, and DESTDIR values used during installation.
SLeeLa
<p align="center"><img src="images/sleela/sleela-wordmark.svg" alt="SLeeLa — The Now. The Ingredient." width="560"></p> <p align="center"><img src="https://github.com/mearvk/SLeeLa/blob/master/images/sleela-programming-language-002.jpg" alt="SLeeLa Marketing Logo" width="560"></p>