Ship architecture. Not repetitive setup.
Nex delivers recipe packages that install config-mapped architecture slices directly into your codebase. Registry, CLI, and documentation stay aligned so teams can move fast without surrendering control.
$ xnex install -r nexcord-core
[registry] package resolved: nexcord-core@1.5.0
[preview] setup.files, setup.scripts, README loaded
[approval] integration plan ready for confirmation
[apply] recipe integrated to recipes/nexcord-core/
$ _
Curated recipe packages
Discover versioned architecture pieces with metadata, README context, and installation entry points.
Config-mapped integration
Use xnex to inspect, approve, and integrate files directly into the target codebase.
Operational clarity
Expose commands, setup scripts, and configuration details before anything touches production code.
Nex behaves like a serious developer platform: controlled integration, project-native output, clear documentation, and inspectable setup before execution.
Libraries solve functions.
Nex distributes architecture.
Traditional package managers stop at dependencies. Nex exposes a structured delivery path for files, scripts, variants, and project integration.
Dependency-first
- Import a library
- Code stays behind package boundaries
- Integration context is mostly manual
- Architecture remains fragmented
- Operational review lives outside the install flow
Architecture-first
- Install the architectural slice you need
- Output lands in your own repository
- README, files, scripts, and variants stay visible
- Approval gates exist inside the workflow
- From package discovery to code ownership in minutes
From registry discovery to project-native delivery
The platform exposes the same questions serious teams ask before installing anything: what will be written, which scripts run, and how the output maps into the codebase.
Discover
Explore packages by problem domain, verify authorship, and compare recipe surface area before installing.
Review
Inspect setup.files, setup.scripts, nexconfig, and README so the integration path is explicit.
Approve
Keep the developer in control with deliberate confirmation around file writes and script execution.
Distribute
Land architecture in the project itself, then adapt it like native code instead of a black-box dependency.
A platform shaped around developer trust
Every touchpoint is built to make the distribution model obvious: discovery in Explorer, operational clarity in docs, and deterministic execution through the CLI.
Explore packages by use case
Search by problem domain, author, and keywords before you ever run a command.
Review setup before apply
Expose files, scripts, variants, and version details as a first-class part of the experience.
Keep architecture inside the project
Output becomes repository code that can be evolved, audited, and maintained by the team.
A workflow that explains itself
Developer-first platforms reduce ambiguity. Nex brings package context, command visibility, and integration review into the same operational lane.
xnex xhelp setup.files / setup.scripts / nexconfig config-mapped output into your repository Command surface, recipe context, and setup visibility
xnex xhelp
Start from the verified command surface and move into install, run, tree, and publish workflows.
Setup preview
Review files, scripts, and variants before applying changes to a project.
Config reference
Understand nexconfig structure, security model, and integration boundaries from one place.
Built for teams that care about control, review, and repeatability
Project-native output
Recipes materialize in your repository, ready for auditing, customization, and long-term ownership.
Operational transparency
CLI, docs, setup, and file structure remain visible from first discovery to final integration.
Developer trust model
Explicit review points make the install path feel controlled, auditable, and suitable for serious teams.
Reusable architecture
Move beyond single-purpose libraries by distributing complete slices such as auth, dashboards, and infra wiring.
Featured Recipes
Production-ready recipe packages from developers building reusable architecture for real-world projects.
Move from ad hoc setup to an architecture distribution workflow
Start in the docs, inspect the command surface, then integrate your first recipe through xnex.
xnex xhelp