github.com/Mjoyufull/Elda @0.1.49

Elda universality in your choices

A Unix-first, Linux-first system package manager written in Rust.

Binary-first delivery, git-capable sources, signed remotes - one ledger for every path under /usr.

Table of Contents

• Features
• Quick Usage
• Status
• Building Elda
• Dependencies
• Configuration
• Package Definition Example
• Documentation

Elda is a Unix-first, Linux-first system package manager written in Rust. It manages /usr as installed state: one package identity and PubGrub-style solver (epoch:pkgver-pkgrel), one SQLite ledger for ownership and rollback, and one transaction path for signed remotes (including dynamic interemotes), Lua recipes (pkg.lua, optional build.lua), git upstreams, vendor/release binaries, interbuild imports (Nix flakes, Gentoo overlays, AUR, XBPS), and interepo foreign indexes. Host backends handle activation, triggers, conffiles, and boot policy on each supported Unix target. Hard fork of pkgit; full contract in SPEC.md.

Features

• Lua recipes - pkg.lua / build.lua, flags, deps, hooks, profiles, conffiles, provider_assets, split packages
• Signed remotes - sync (all or named remotes), channels, TOFU/pinned trust, key rotation, cache-first payloads
• Interemotes - Gentoo overlay / XBPS srcpkgs git remotes with rmt preview, --exclude, sync deltas and parser diagnostics
• Source and binary lanes - same package name; ig / ib, release assets, AppImage, GPKG, vendor-generated recipes
• Foreign packaging - interbuild parsers (Nix, Gentoo, AUR, XBPS) and interepo adapters into one staging model
• SQLite ledger - ownership, manifests, files / files search, verify/recover, prefix and /usr rollback
• Operator surfaces - install preflight, live progress, review stamps, doctor, config pending/apply, trigger ls/info
• Recipe & git ops - rc show / diff / publish-ready, vendor import/export, git releases / tags, metadata add with --replace
• Policy & introspection - pin/hold, why / rdeps / autoremove, downgrade, fl check / diff, provider preferences
• Forge publishing - ci / forge / qa, hosted ci pr, signed indexes, populate cache mirror/push
• Init-agnostic - provider assets for systemd, OpenRC, runit, dinit, and similar; no mandated init
• Staged transactions - build -> stage -> verify -> activate with journaled mutations on system backends

Quick Usage

# Inspect the CLI (see also examples/ and USAGE.md)
elda --help
elda i --help
elda rmt add --help

# Register a native remote and sync (illustrative URLs and keys - example remote only)
elda rmt add yoka-main=https://github.com/Mjoyufull/Elda/releases/download/index/index-v1.json.zst \
  --trust pinned \
  --trusted-key ed25519:0011223344556677889900112233445566778899aabbccddeeff0011223344 \
  --packages-url https://github.com/Mjoyufull/Elda.git
elda sync

# Search and install
elda search fsel
elda i fsel
elda ig fsel      # force source lane
elda ib fsel      # force binary lane

# Add local metadata without overwriting existing metadata
elda a https://github.com/Mjoyufull/fsel
elda a https://github.com/Mjoyufull/fsel --replace

# Dynamic interemote: --exclude must come at the END of the flag list
elda rmt add heather-overlay=https://github.com/heather7283/heather7283-overlay --exclude firefox vlc
elda rmt preview heather-overlay
elda sync heather-overlay

# Inspect state and bootstrap health
elda doctor
elda ls
elda info fsel

For the full operator guide, use USAGE.md. For hosting native indexes, forges, and caches end to end, see eldaforgehosting/.

[!WARNING] Documentation examples: URLs, remote names, signing keys, and third-party repository names used in this repository's docs are strictly illustrative unless you recognize them as your own infrastructure. Replace them with your index URLs, packages_url, trust material, and cache bases.

[!TIP] examples/: The examples/ tree is the primary reference for pkg.lua layouts, profile snippets, import inputs, and annotated config.toml fragments.

Status

Overall (toward full SPEC.md scope): ~68%

Active development. Native slice covers install/upgrade/remove, signed remotes and interemotes (preview, targeted sync), review gates, inspection commands, forge/CI publish, and bounded interbuild/migration import; interepo install and merged-tree host activation are not. Prefer disposable roots; treat live /usr as experimental. Ledger detail: phase.md.

Feature checklist (current tree)

Legend: [x] done in the current slice · [~] partial · [ ] not started

• [x] pkg.lua / build.lua - parse, validate, install; flags, provider assets, meta/profile packages
• [x] Source lanes - git, local recipes, synced packages_url trees; Cargo, CMake, Meson, Make, Go, Python, Zig, Nimble
• [x] Binary lanes - URLs, forge release_asset, GPKG, AppImage + appimage inspect, vendor add/import/export
• [x] Signed remotes - TOFU/pinned trust, channels, key rotation, release-asset signature keys, offline snapshots, cache priority and cleanup
• [x] Interemotes - dynamic Gentoo/XBPS git remotes, rmt preview/trust/info, --exclude, sync <remote> deltas
• [x] Solver - install/upgrade/downgrade; pins, holds, providers, weak deps, replaces; why / rdeps / autoremove
• [x] SQLite state - ownership, manifests, files search, verify/recover, conffile queue, prefix rollback
• [x] /usr backend - staged activation, triggers, fix-triggers, provider assets, archive rollback (not final host model)
• [x] Profiles - pf edit/apply, machine shape, init/foreign-arch policy, state export/import
• [x] Inspection - rc show/diff/publish-ready, config pending/diff/apply, trigger ls/info, doctor
• [x] Review - generated-metadata and interbuild gates, review ls/info/forget/diff, content-addressed stamps
• [x] Forge - ci/forge/qa, local publish (lock/index/sidecars), hosted ci pr with token/bearer auth; elda-populate cache mirror
• [x] Interbuild - bounded Nix flake, Gentoo overlay, AUR PKGBUILD, XBPS template parsers + review metadata
• [~] Operator bootstrap - preflight, live progress, privilege handoff; full setup/takeover still open
• [~] Migration - mg from / adopt for pacman, apt, apk, xbps, portage DBs; no live file takeover yet
• [ ] Interepo: translated foreign snapshots install end-to-end
• [ ] Coexistence / lock / live takeover modes vs other package managers
• [ ] Host activation: merged-tree materialization and atomic /usr exchange (see phase.md)

More detail: full kanban and phase tables in checklist.md. Contract: SPEC.md. Changelog: phase.md.

Building Elda

What you need

Elda does not need CMake, Meson, Go, Zig, Nimble, or other build tools on the host that compiles Elda. Those are only needed on machines where you build packages through Elda (source-lane recipes).

Example distro packages:

# Arch Linux
sudo pacman -S --needed base-devel git rust pkgconf zstd xz

# Debian / Ubuntu
sudo apt install build-essential git pkg-config libzstd-dev liblzma-dev
# Then install Rust 1.94+ with rustup if the distro rustc is too old.

Build and install the binary

git clone https://github.com/Mjoyufull/Elda
cd Elda
cargo build --release

Run from the workspace while developing:

cargo build
./target/debug/elda --help

Install the binary somewhere on your PATH when you are ready to use it outside the checkout:

install -Dm0755 target/release/elda ~/.local/bin/elda

Dependencies

Workspace crates

The Cargo workspace (Cargo.toml) builds these members:

Rust libraries (Cargo)

Shared workspace dependencies:

Additional dependencies outside the workspace table:

Host programs (runtime, by feature)

These are not required to compile Elda. Install them when you use the matching recipe lane or command.

Network access is required for elda sync, remote binary lanes, and release-asset fetch unless you use --offline with a verified local cache/snapshot.

What works today

Roughly, the current tree can:

• Parse and install pkg.lua recipes (deps, conflicts, replaces, conffiles, hooks, profiles, meta packages, and the rest of the metadata surface in the spec).
• Build from git/local source (Cargo, CMake, Meson, Make, Go, Python, Zig, Nimble) or pull binaries (URLs, GitHub/GitLab/Gitea releases, GPKG, AppImage, generated vendor recipes).
• Sync signed remotes, pin trust, use caches/offline snapshots, and wire dynamic Gentoo/XBPS-style interemotes.
• Plan installs with the solver (upgrade/downgrade, pins, holds, providers, weak deps).
• Keep state in SQLite: ownership, manifests, verify, rollback, conffiles, disposable /usr tests, first real host backend.
• Run local ci / forge