<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/">
    <channel>
        <title>Zillowe Articles</title>
        <link>https://zillowe.qzz.io/</link>
        <description>Latest insights and updates from the Zillowe Foundation.</description>
        <lastBuildDate>Thu, 13 Aug 2026 10:17:24 GMT</lastBuildDate>
        <docs>https://validator.w3.org/feed/docs/rss2.html</docs>
        <generator>https://github.com/jpmonette/feed</generator>
        <language>en</language>
        <copyright>All rights reserved 2026, Zillowe Foundation</copyright>
        <item>
            <title><![CDATA[ZSM: The Future of Installation Scripts]]></title>
            <link>https://zillowe.qzz.io/articles/future-of-installation-scripts</link>
            <guid isPermaLink="false">https://zillowe.qzz.io/articles/future-of-installation-scripts</guid>
            <pubDate>Mon, 06 Jul 2026 00:00:00 GMT</pubDate>
            <description><![CDATA[An introduction to ZSM, a modern, security-first replacement for bash-based installation scripts.]]></description>
            <content:encoded><![CDATA[

Running `curl -fsSL <https://example.com/install.sh> | bash` is a common but dangerous pattern. It grants arbitrary, unvetted execution privileges to a remote script, often requiring sudo.

You *cannot* trust a foreign script running on your local machine without reading it first, but for most people that is not the case they just trust whatever the script contains and run it.

## The ZSM Solution [#the-zsm-solution]

Zillowe Script Manager (ZSM) introduces a Capability-based Security model for installation scripts. Instead of running imperative shell code, you run a `.zsm` script that declares the permissions it needs. ZSM acts as a complete lifecycle manager.

<Callout>
  Please note that this is mainly a proof-of-concept and may not be ideal for
  most applications, want to improve it? [Contribute
  Here](https://gitlab.com/zillowe/zillwen/zusty/zsm).
</Callout>

### Key Features [#key-features]

* **Declarative Permissions:** Scripts must explicitly request access to the network, filesystem, or system configuration.

* **Deep Supervision:** Lock external binaries to specific argument patterns (e.g. `require bin: curl --silent`).

* **User Approval & Persistence:** Users review and approve specific capabilities before any code runs. Approvals are securely cached based on the script's URL.

* **Full Lifecycle Management:** ZSM tracks created files and supports `zsm uninstall` for clean removal, including custom uninstall hooks.

* **Small & Portable:** Built with Zig 0.16.0 for zero-dependency, high-performance execution.

## Getting Started [#getting-started]

You can install ZSM via [Zoi](/zds/zoi):

```bash
zoi install @zillowe/zsm
```

### Usage [#usage]

ZSM can fetch and run scripts natively or via pipes:

```bash
# Native execution
zsm install https://example.com/install.zsm

# Piped execution
curl -fsSL https://example.com/install.zsm | zsm
```

### Script Example [#script-example]

ZSM scripts use a declarative format to specify metadata and requirements, followed by safe built-in logic, this is a real example from Zoi `install.zsm`:

```bash title="install.zsm" lineNumbers
#!/usr/bin/env zsm

# :: name: zoi
# :: version: latest
# :: url: zillowe.pages.dev/zoi/install.zsm
# :: description: Installer for Zoi
# :: require bin: tar, zstd
# :: perm net: gitlab.com, zillowe.pages.dev
# :: perm fs: /tmp, ~/.local/bin

GITLAB_PROJECT_ID="71087662"
GITLAB_PROJECT_PATH="zillowe/zillwen/zusty/zoi"
BIN_NAME="zoi"

OS = system.os()
ARCH = system.arch_mapped()

LATEST_TAG = web.get_json_field("https://gitlab.com/api/v4/projects/${GITLAB_PROJECT_ID}/releases", "tag_name")

REPO_BASE_URL="https://gitlab.com/${GITLAB_PROJECT_PATH}/-/releases/${LATEST_TAG}/downloads"
TARGET_ARCHIVE="zoi-${OS}-${ARCH}.tar.zst"
DOWNLOAD_URL="${REPO_BASE_URL}/${TARGET_ARCHIVE}"

web.download("${DOWNLOAD_URL}", "/tmp/${TARGET_ARCHIVE}")
run zstd -dc "/tmp/${TARGET_ARCHIVE}" | run tar -xf - -C "/tmp"

fs.move("/tmp/zoi", "~/.local/bin/zoi")
fs.chmod("~/.local/bin/zoi", "755")
```

Please check out the [docs](/docs/zds/zsm) for more information.
]]></content:encoded>
            <author>Zaid</author>
        </item>
        <item>
            <title><![CDATA[Zoi: The Advanced Package Manager and Environment Orchestrator]]></title>
            <link>https://zillowe.qzz.io/articles/zoi</link>
            <guid isPermaLink="false">https://zillowe.qzz.io/articles/zoi</guid>
            <pubDate>Wed, 25 Feb 2026 00:00:00 GMT</pubDate>
            <description><![CDATA[An introduction to Zoi, the ultimate cross-platform package manager designed to unify development environments across Linux, macOS, and Windows.]]></description>
            <content:encoded><![CDATA[

Setting up a consistent development environment across different machines and operating systems has historically been a fragmented and frustrating process. Developers often find themselves wrestling with disparate package managers, `apt` on Ubuntu, `brew` on macOS, `scoop` on Windows, alongside language-specific tools like `npm`, `cargo`, and `pip`.

**Zoi** (part of the [Zillowe Development Suite](/docs/zds)) was created to solve this fragmentation. It is a universal, cross-platform package manager that provides a unified interface for managing software, project dependencies, and development environments.

## Why Zoi? [#why-zoi]

Traditional package managers are usually tied to a specific operating system or ecosystem. Zoi takes a different approach by acting as a high-level orchestration layer. It doesn't just install its own packages; it integrates with over **40 external package managers**, allowing you to define a single environment that works everywhere.

### Key Features [#key-features]

* **Cross-Platform:** Native support for Linux, macOS, and Windows (supporting both `amd64` and `arm64`).
* **Lua-Powered Flexibility:** Package definitions are written in Lua (`.pkg.lua`), allowing for dynamic logic, complex build steps, and platform-specific adaptations that static configuration files can't handle.
* **Universal Dependencies:** Declare dependencies from `apt`, `pacman`, `brew`, `npm`, `cargo`, `pip`, `go`, `bun`, and many more in one place.
* **Secure & Verifiable:** Built-in support for SHA-512/256 checksums and PGP signature verification for every package.
* **Versatile Package Types:** Beyond standard software, Zoi supports **Collections** (metapackages), **Apps** (project templates), and **Extensions** (Zoi configuration modifiers).
* **Advanced CLI Tools:** Features like `zoi why` (dependency inspection), `zoi rollback` (transactional reverts), `zoi pin` (version locking), and `zoi exec` (run without installing).
* **Parallel Registry Sync:** Concurrently sync multiple package registries for significantly faster updates.
* **Zoi Mini:** A lightweight, zero-sync version for quick, one-off installations.

***

## The Power of `.pkg.lua` [#the-power-of-pkglua]

Most package managers use static formats like YAML or JSON. Zoi uses Lua, giving package maintainers the full power of a scripting language.

```lua title="hello.pkg.lua" lineNumbers
-- A snippet from a Zoi package definition
metadata({
  name = "hello",
  repo = "zillowe",
  version = version,
  description = "Hello World",
  website = "https://github.com/zillowe/hello",
  git = git_url,
  bins = { "hello" },
  types = { "source" },
  tags = { "zillowe", "example", "hello", "cli" },
})

function prepare()
  cmd("git clone --depth 1 --branch " .. "v" .. version .. " " .. PKG.git .. " source")
  cmd("cd " .. BUILD_DIR .. "/source && zig build --release=small -Dtarget=" .. get_zig_target())
end

function package()
  local bin_name = "hello"
  if SYSTEM.OS == "windows" then
    bin_name = "hello.exe"
  end
  zcp("source/zig-out/bin/" .. bin_name, "${pkgstore}/bin/" .. bin_name)
end
```

This flexibility ensures that complex software can be packaged correctly for any target system without maintaining separate scripts for every OS.

***

## Zoi Mini: Zero-Sync Installation [#zoi-mini-zero-sync-installation]

Zoi Mini is a specialized version of the Zoi engine that operates without a local database. It resolves package metadata and vulnerabilities on the fly from the [Zoidberg](/docs/zds/zoi/zoidberg) registry. This makes it perfect for "as-a-service" scenarios and one-liner installations.

### Quick Start (Zero-Install) [#quick-start-zero-install]

You can install any package from the Zoidberg registry using a single command without even having Zoi installed:

**Linux / macOS:**

```sh
curl -fsSL https://zillowe.pages.dev/zm.sh | sh -s -- i @zillowe/hello
```

**Windows (amd64):**

```powershell
powershell -c "irm zillowe.pages.dev/zm.ps1 | iex" -args "i @zillowe/hello"
```

***

## Project Environments with `zoi.yaml` [#project-environments-with-zoiyaml]

Zoi isn't just for global software; it shines in project-local management. By placing a `zoi.yaml` in your repository, you can:

* Define project-specific packages.
* Create custom aliases for common tasks (`zoi run dev`).
* Set up isolated development environments (`zoi dev`).
* Ensure every team member has the exact same tools via `zoi.lock`.

***

## Getting Started [#getting-started]

To install the full Zoi suite:

**Linux / macOS:**

```sh
curl -fsSL https://zillowe.pages.dev/scripts/zoi/install.sh | bash
```

Or if you want a truly safe way to run this script use [ZSM](/articles/future-of-installation-scripts).

```sh
curl -fsSL https://zillowe.pages.dev/scripts/zoi/install.zsm | zsm
```

**Windows:**

```powershell
powershell -c "irm zillowe.pages.dev/scripts/zoi/install.ps1|iex"
```

After installation, run `zoi sync` to fetch the official [Zoidberg](/docs/zds/zoi/zoidberg) registry and you're ready to start!

***

## Learn More [#learn-more]

Zoi is a deep tool with many advanced features for power users and package maintainers. Explore the links below to dive deeper:

* **[Zoi Documentation Home](/docs/zds/zoi)**: The starting point for all Zoi guides.
* **[Creating Your First Package](/docs/zds/zoi/creating-packages)**: A step-by-step guide to the Zoi packaging API.
* **[Supported Dependency Managers](/docs/zds/zoi/dependencies)**: See the full list of 40+ integrated managers.
* **[Zoidberg Repository](https://gitlab.com/zillowe/zillwen/zusty/zoidberg)**: Browse the official package database.
]]></content:encoded>
            <author>Zaid</author>
        </item>
    </channel>
</rss>