An ecosystem of self-hosted, privacy-first, open-source software projects designed for individuals and organizations that value ownership, simplicity, independence, and long-term maintainability.

The 9 Principles Explore Projects

The NX9 Manifesto

From these principles naturally follows the engineering philosophy:

The Nine Principles of NX9

A response to the increasing complexity of modern software stacks, cloud dependency, vendor lock-in, subscriptions, telemetry, and unnecessary frameworks.

1. Self-Hostable First

Every NX9 application must run on infrastructure owned and controlled by its users. Cloud services may complement—but must never be required for—the software to function.

Self-hosted Independence Ownership

2. User Ownership

Users own their data, configuration, backups, deployment, upgrade path, and operational future. Software must never create dependency on a vendor.

Ownership Data Control

3. Privacy by Design

Privacy is the default—not an optional feature. NX9 software includes absolutely no telemetry, tracking, analytics, surveillance, profiling, or mandatory accounts.

Privacy Trust Respect

4. Freedom Through Open Source

Every NX9 project is permanently Free and Open Source Software (MIT or Apache-2.0). Users must always be free to study, modify, redistribute, and fork the software.

Freedom Transparency Community

5. Linux Native

NX9 embraces Unix philosophy and Linux conventions. Applications should integrate naturally with systemd, POSIX, shell scripting, standard filesystem hierarchies, and journald.

Linux Unix Native

6. Simplicity Over Complexity

Every feature, dependency, and abstraction must justify its existence. We prefer fewer components, smaller binaries, readable code, and understandable architecture.

Simplicity Clarity Maintainability

7. CLI First

Every capability should be available from the command line. Graphical interfaces enhance usability but must never replace automation or scripting.

CLI Automation Power

8. Open Standards

NX9 favors mature, well-documented, vendor-neutral technologies over proprietary ecosystems. We avoid unnecessary proprietary protocols, formats, and lock-in.

Standards Compatibility Longevity

9. Longevity

Built for decades—not development cycles. Software should survive changing trends, disappearing companies, and evolving ecosystems. Technology changes; good engineering endures.

Durability Stability Future-proofing

Engineering Philosophy

Prefer standards over frameworks. Avoid requiring Node.js or Python at runtime. Minimize unnecessary dependencies and operational complexity.

Technologies NX9 Embraces

Languages

  • Rust (preferred)
  • C & C++
  • Go
  • POSIX Shell

Web & APIs

  • HTML5 & CSS3
  • Vanilla JS (ECMAScript)
  • REST & HTTP
  • JSON

Databases

  • SQLite (default)
  • PostgreSQL (optional)

Platforms

  • Linux (primary)
  • BSD (practical)

Technologies NX9 Avoids

We avoid these to reduce dependency trees, bloat, and runtime overheads—leaving room for exceptional cases only when truly justified.

Front-end Frameworks

  • React, Vue, Angular
  • Svelte, Next.js, Nuxt
  • Remix, Astro, Qwik

CSS & JS Libraries

  • Tailwind, Bootstrap
  • Material UI, Bulma
  • jQuery, Alpine.js
  • Stimulus, Ember

Build Toolchains

  • npm (as runtime)
  • Yarn, pnpm, Bun
  • Webpack, Vite
  • Rollup, Gulp

Runtimes & Architectures

  • Node.js (as runtime)
  • Python (as runtime)
  • Vendor lock-in
  • Telemetry-first design

The Ecosystem

The NX9 ecosystem is planned as nine interoperable projects sharing a common philosophy, consistent documentation, and minimal dependencies.

"Software people can own, understand, and control." — The Official Motto of NX9.