v3.1.0 Open Source Apache 2.0 5 languages 6 AI platforms 11-stage pipeline

Specify Once.
Generate Everything.

From a single YAML spec, NAEOS generates complete projects — code, CI/CD, docs, deployment manifests, and AI context — across 5 languages and 6 AI platforms. Stop scaffolding. Start shipping.

Get Started View on GitHub
terminal — naeos
$ naeos init
✓ Config initialized: naeos.yaml
$ cat spec.yaml
project: my-app
modules:
- name: api
path: ./api
generation:
languages: [go, typescript]
$ naeos run --input spec.yaml
✓ Parsed → Normalized → Resolved
✓ NEIR built | 4 modules, 8 services
✓ Policy evaluation: passed
✓ Generated: go/, typescript/
✓ Done in 1.2s
NEW v3.0.0 — Pipeline profiling, stage caching, NEIR-aware LSP server, and official plugin examples. See what's new →

One spec. Your entire stack.

Declarative spec → validated projects in every language and every AI assistant your team already uses.

Languages

AI Platforms

Infrastructure

Without NAEOS

Scaffolding is a tax on every project

Hand-writing boilerplate across five languages, keeping READMEs in sync with APIs, re-prompting AI assistants with architecture context — it compounds on every service you ship. Most teams spend weeks wiring projects before writing a single line of business logic.

  • Boilerplate drift between languages and repos
  • AI assistants without architecture context
  • Docs, CI, and deployment configs maintained by hand
With NAEOS

Specify once. Build anywhere.

NAEOS reads a single YAML/JSON specification, builds a canonical internal model (NEIR), and orchestrates the full engineering lifecycle — code, tests, CI/CD, deployment manifests, docs, and AI context — all traceable from intent to implementation.

  • Single source of truth: the spec is the system
  • 11-stage pipeline with governance gates
  • AI context bundles for every assistant
Get Started

How it works

Three steps between an idea and a production-ready project.

1

Describe

Declare modules, services, architecture, and infrastructure in one YAML file. The spec is the single source of truth — no code yet, just intent.

spec.yaml
project: my-app
architecture:
  pattern: microservices
services:
  - name: gateway
    kind: http
    port: 8080
2

Model

NAEOS builds the NEIR intermediate representation: dependency graphs, validation, and policy evaluation catch problems before generation.

NEIR
✓ modules: 4
✓ services: 8
✓ dependencies: 12
✓ architecture: microservices
✓ policies: passed
3

Generate

Production-ready projects in Go, TypeScript, Python, Java, or Rust — plus CI/CD, Docker/K8s manifests, docs, and AI context for 6 assistants.

output/
├── go/            # Go services
├── typescript/    # TS services
├── infra/         # K8s + Terraform
├── ci/            # GitHub Actions
└── ai/            # Context bundles

One pipeline. Eleven stages.

Every stage is observable, cacheable, and extensible via plugins — from parsing to artifact output.

1
Parse
2
Normalize
3
Resolve
4
Build NEIR
5
Validate
6
Build Graph
7
Policy
8
Schedule
9
Generate
10
Review
11
Artifacts

Core Features

67+ CLI commands · 5 languages · 6 AI platforms · 56+ specifications — one unified engineering system.

Pipeline Engine

11-stage DAG pipeline from spec to shipped code. Each stage is observable, cacheable, and extensible via plugins. Inspect every transformation from YAML to artifact.

AI Compiler

Feed your architecture directly into coding assistants. AI context bundles give Copilot, Claude, Cursor, Gemini, Codex, and OpenCode full system awareness — no more repeated prompting.

Code Generator

Production-ready code in Go, TypeScript, Python, Java, and Rust. Per-language adapters generate idiomatic project structures, tests, and dependency files out of the box.

NEIR Model

A canonical model of your entire system — project structure, architecture, modules, services, APIs, infrastructure, and security policies. NEIR is the bridge between your intent and every generated artifact.

Governance & Policy

Enforce architecture rules before they hit production. Policy engine with 7 operators, RBAC, full audit trails, and artifact review. Catch violations during generation, not deployment.

Marketplace

Publish, discover, and install industry profiles and plugins. 5 built-in profiles (SaaS, AI Agent, FinTech, Healthcare, Government) plus a growing community registry.

CLI Commands+
Languages
AI Platforms
Specifications

Use Cases

From solo devs to platform teams — NAEOS adapts to how you build.

Microservices Architecture

Define your entire service mesh in one spec. Generate Go and TypeScript services with REST endpoints, Dockerfiles, and production-grade Kubernetes manifests — all from a single YAML.

Go · TypeScript

Serverless Applications

Describe event sources and function chains. Generate deployable Python and TypeScript handlers with IAM policies, event mappings, and framework configuration included.

Python · TypeScript

AI-Native Development

Compile your architecture into AI instruction sets. Your coding assistants start with full context — module structure, dependencies, API contracts — without copying READMEs into every prompt.

6 AI Platforms

Enterprise Governance

Prevent architecture drift across teams. RBAC, audit trails, and a policy engine with 7 operators catch violations during generation — not after deployment.

Governance

Try It Live

Edit a specification and inspect the resulting NEIR model structure immediately.

spec.yaml

NEIR Model Preview

Edit the specification on the left to update this preview.

Quick Start

From idea to generated project in under 60 seconds.

1

Install NAEOS

Install with Go, use Docker, or download a ready-to-run binary.

bash
go install github.com/NAEOS-foundation/naeos/cmd/naeos@latest
2

Create a Specification

Describe your project structure in YAML or JSON.

yaml
project: my-app
modules:
  - name: auth
    path: ./auth
  - name: api
    path: ./api
    dependencies: [auth]
services:
  - name: gateway
    kind: http
    port: 8080
generation:
  languages: [go, typescript]
3

Run the Pipeline

Parse, validate, generate, and export the complete project.

bash
naeos run --input spec.yaml --output-dir ./out
4

Compile AI Context

Generate instruction sets for Copilot, Claude, Cursor, and other coding assistants.

bash
naeos ai compile --input-file spec.yaml --target opencode

Loved by Engineers

Hear from teams that ship with NAEOS every day.

We replaced three code generators and a wiki with one NAEOS spec. Scaffolding a new Go + TypeScript service now takes seconds instead of hours.

SK

Sarah Kim

Platform Engineer · FinTech

The AI context bundles are a game changer. Claude Code understands our full architecture without me pasting README excerpts into every single prompt.

JR

James Reyes

Full-Stack Developer · SaaS Startup

We migrated 12 services to NAEOS. The governance engine flagged three architecture violations during generation — caught them before they ever hit a PR.

AN

Aditya Nugraha

Engineering Lead · E-Commerce

Latest from the Blog

News, tutorials, and deep dives from the NAEOS team.

release
Aug 16, 2026

NAEOS v3.1.0 Release

NAEOS v3.1.0 is now available with pipeline caching on naeos run, run-level profiling, new architecture patterns, and …

read 2 min
announcement
Aug 1, 2026

NAEOS Official Whitepaper Published

The official NAEOS whitepaper is now available — a comprehensive technical document covering vision, architecture, the …

read 1 min
Blog →

Backed by the Community

—
GitHub Stars
—
Forks
—
Open Issues
—
Contributors

Supported Languages

5 languages + 6 AI platforms — one unified engineering system.

Languages

Go TypeScript Python Java Rust

AI Platforms

⟐GitHub Copilot
◉Claude Code
⟡Cursor
◇Gemini CLI
⊡Codex
◈OpenCode

Ship your next project in minutes, not weeks

Install NAEOS with one command and generate your first project in under a minute.

bash
go install github.com/NAEOS-foundation/naeos/cmd/naeos@latest
Get Started Install Now

We use cookies to analyze traffic and improve your experience. By using our site, you consent to our use of cookies.