Skip to content

Installation

The Naftiko Fleet is a family of small, focused components that you install independently. With the v1.0.0-beta2 release the full Fleet is now available end-to-end: authoring (Crafter), linting (Polychro), running (Ikanos), governance (Warden), and orchestration (Skipper). Pick the components you need today, add the others when you're ready.

Component What it does How you install it
Ikanos Runs your YAML capabilities as MCP / REST / Skill servers (multiple capabilities, side by side) Docker image or native CLI (Linux / macOS / Windows)
Polychro Lints your specs against schema + bundled rulesets Native CLI or Java library
Crafter Authors capabilities (formerly the Naftiko VS Code extension) VS Code Marketplace
Warden Governs capabilities from your developer portal (formerly the Naftiko Backstage plugin) Backstage plugin package
Skipper Orchestrates capabilities on Kubernetes (Operator + Helm chart) Helm chart

Open source under it all

Ikanos and Polychro are Apache 2.0 standalone projects. Crafter, Warden, and Skipper are part of the Naftiko Fleet under the Freeware EULA (Community) and the Naftiko Commercial License (Developer / Team / Enterprise). Every capability YAML file you author works identically across all components.

Ikanos engine

Prerequisites:

  • Docker, Docker Desktop, or any OCI-compatible runtime
  • One or more capability YAML files you want to run
# Pull the latest stable release
docker pull ghcr.io/naftiko/ikanos:v1.0.0-beta2

# Or pull the rolling snapshot
docker pull ghcr.io/naftiko/ikanos:latest

Run it against a local capability file:

docker run -p 8081:8081 \
  -v "$(pwd)/my-capability.yml:/app/capability.yml" \
  ghcr.io/naftiko/ikanos:v1.0.0-beta2 \
  /app/capability.yml

docker run -p 8081:8081 `
  -v "${PWD}\my-capability.yml:/app/capability.yml" `
  ghcr.io/naftiko/ikanos:v1.0.0-beta2 `
  /app/capability.yml

Localhost inside containers

When your capability references a service running on your host machine, use host.docker.internal instead of localhost. To expose a server from inside the container, bind on 0.0.0.0 rather than 127.0.0.1.

Option B — Native CLI

Download the binary for your platform from the Ikanos releases page.

curl -L https://github.com/naftiko/ikanos/releases/latest/download/ikanos-cli-macos-arm64 -o ikanos
chmod +x ikanos
xattr -d com.apple.quarantine ikanos
sudo mv ikanos /usr/local/bin/

curl -L https://github.com/naftiko/ikanos/releases/latest/download/ikanos-cli-linux-amd64 -o ikanos
chmod +x ikanos
sudo mv ikanos /usr/local/bin/

New-Item -ItemType Directory -Force -Path "C:\Program Files\Ikanos"
Invoke-WebRequest `
  -Uri "https://github.com/naftiko/ikanos/releases/latest/download/ikanos-cli-windows-amd64.exe" `
  -OutFile "C:\Program Files\Ikanos\ikanos.exe"
$oldPath = [Environment]::GetEnvironmentVariable('Path','Machine')
[Environment]::SetEnvironmentVariable('Path', "$oldPath;C:\Program Files\Ikanos", 'Machine')

Verify the install:

ikanos --help

Ikanos can run multiple capabilities in parallel out of the box — either as separate processes (one capability per container or binary invocation) or, declaratively, under Skipper on Kubernetes. See First fleet for both patterns.

Polychro linter

Option A — Native CLI

# macOS / Linux
curl -L https://github.com/naftiko/polychro/releases/latest/download/polychro-$(uname -s | tr A-Z a-z)-amd64 -o polychro
chmod +x polychro && sudo mv polychro /usr/local/bin/

# Lint a spec
polychro lint my-capability.yml

Option B — As a Java library

<dependency>
    <groupId>io.polychro</groupId>
    <artifactId>polychro-core</artifactId>
    <version>0.1.0</version>
</dependency>

See the Polychro getting-started guide for the full Java API.

VS Code extension — Edit and lint capabilities

Crafter is the Fleet's VS Code extension.

Install from the VS Code Marketplace:

code --install-extension naftiko.crafter

Or search for Naftiko Crafter in the Extensions view (Ctrl+Shift+X / Cmd+Shift+X) and click Install.

Files saved as *.ikanos.yaml or *.ikanos.yml — or any YAML file tagged with a # @ikanos modeline — activate JSON Schema validation, embedded Polychro rules, and inline diagnostics directly in the editor — no CLI required. OpenAPI 3.1 / 3.0 / Swagger 2.0 documents are validated too. See Components → Crafter for the full feature list and Crafter → Usage for day-to-day usage.

Backstage integration — Scaffold and manage capabilities

Warden is the v1.0 Alpha 3 rename of the Naftiko Backstage plugin. It surfaces every capability in your developer portal, attaches policy to it (built on Polychro rulesets), and produces an audit trail of decisions.

Install the plugin in your Backstage app:

# In the Backstage frontend
yarn --cwd packages/app add @naftiko/plugin-warden

# In the Backstage backend
yarn --cwd packages/backend add @naftiko/plugin-warden-backend

Then register the plugin routes — see Components → Warden for the full integration guide and policy authoring reference.

Kubernetes integration — Deliver and serve capabilities

Skipper is the new Kubernetes operator that turns Capability custom resources into running Ikanos workloads. It ships in v1.0.0-beta2 as a Helm chart that installs the operator, CRDs, and default CapabilityClass.

helm repo add naftiko https://charts.naftiko.io
helm repo update

helm install skipper naftiko/skipper \
  --namespace naftiko-system --create-namespace \
  --version 1.0.0-beta2

Verify the install:

kubectl get crds | grep naftiko
kubectl -n naftiko-system get pods

Once the operator is running, declare capabilities the Kubernetes way:

apiVersion: naftiko.io/v1alpha1
kind: Capability
metadata:
  name: registry
spec:
  source:
    configMapRef:
      name: registry-spec
      key: registry.ikanos.yml
  class: standard

See Components → Skipper for the CRD reference, GitOps patterns, and multi-region orchestration.

Next steps