The Problem

Installing third-party software on Linux distros like Debian or Ubuntu is rarely sudo apt install. Proprietary apps need repo setup, GPG keys, and distro-specific workarounds. Toolchains like Rust and uv deliberately bypass system package managers. Nixite turns that manual, error-prone process into a single generated bash script.

What This Does

Nixite is a web app and generator that produces an unattended bash install script for your chosen Linux software. It selects the best install method per package: system package manager, Flatpak, Snap, or a custom installer. The registry at registry/ holds 95 TOML files, each defining how a package installs across Debian, Ubuntu, Fedora, and Arch.

The frontend is an Astro app (src/pages/index.astro) with React components (src/components/). Package definitions in TOML are compiled into src/categories.json via registry.py, which the UI reads. The generator logic lives in src/scripts/nixite.ts and src/scripts/index.ts.

How It Is Wired

Execution starts at src/scripts/index.ts, which imports src/scripts/nixite.ts. That module is the hub: 2 modules import it, and it exports the core script-generation logic. The import graph is small — 6 internal modules, 2 edges, no cycles — so changing the generator is low-risk.

A run does this:

  1. registry.py (Python, 56 lines) parses registry/*.toml and writes src/categories.json. It has 16 branch points over 56 lines — dense decision logic.
  2. The Astro frontend reads src/categories.json and renders checkboxes per category.
  3. The user's selections feed nixite.ts, which loops over chosen packages, reads their TOML definitions, and emits bash commands.
  4. Output is a standalone script the user runs with sudo.

The shell scripts registry/@common.sh, @debian.sh, @ubuntu.sh, @arch.sh, @fedora.sh are shared snippets referenced by TOML entries. search_pkgs.py queries distro repos for package names.

The widest blast radius is src/scripts/nixite.ts — everything routes through its generator. A bug there produces broken install scripts for every user.

How To Use It

git clone https://github.com/moses-y/nixite
cd nixite
bun install        # bun.lock present; bun is the package manager
bun run dev        # start Astro dev server

To regenerate the registry after editing TOML files:

python registry.py && prettier -uwu src/*.json

No environment variables or config files are required. The web UI at the dev server URL handles everything interactively.

Real-World Use

A user on Ubuntu Desktop wants Chrome, VS Code, and Rust. They open the app, tick those packages, and get a script that adds Google's repo and GPG key, installs VS Code via its apt repo, and runs the rustup installer — all without manual steps. The script is re-runnable and skips already-installed tools via skip_if_exists.

Code Health & Issues

Static analysis found 4 medium-severity issues across 3 kinds:

  • Medium (cognitive load) — Deep nesting (max indentation depth 7) in src/pages/index.astro and src/scripts/index.ts. Flatten with guard clauses.
  • Medium (clarity) — Duplicated 6-line blocks across registry/@debian.sh and registry/@ubuntu.sh. Extract shared helpers.
  • Medium (cognitive load) — High branching density in registry.py: 16 branch points over 56 lines. Consider table-driven dispatch.

SDLC observations from the file structure:

  • High — No LICENSE file; redistribution rights are undefined. Add MIT or Apache-2.0.
  • Medium — No tests, no CI/CD pipeline, no lockfile (only bun.lock). package.json has no lockfile, so builds are not reproducible without Bun.
  • Low — No Dependabot or Renovate config; dependency updates are manual.

The Bottom Line

Nixite solves a real pain point well: it distills distro-specific install logic into a clean TOML registry and a working web UI. The codebase is small and the import graph is simple. The main risks are the missing license, no test coverage, and the dense branching in registry.py — all fixable. Worth using for anyone who regularly sets up Linux machines or maintains a personal package list.