Edition 2026.3 Python + PyTorch backend SaaS-ready compiler core

Hyperbridge Digital · Kynetra language systems

KynML

A compiler-first ML training platform: one readable `.kyn` file becomes validated data contracts, reproducible PyTorch, and a path to hosted training workflows.

kynml train examples/house_price.kyn

Read the language See the pipeline View SaaS layer

parse -> validate -> generate -> train

5 language blocks

9 CLI commands

5 working examples

4 adjacent tools mapped

Language surface

Write the training intent. Let the compiler carry the boilerplate.

KynML v1 is intentionally narrow: CSV datasets, dense networks, core losses, metrics, optimizers, and Torch export. That restraint is the feature.

Compiler pipeline

Small language, real compiler shape.

The MVP stays approachable while leaving clean boundaries for ONNX, JAX, MLIR, distributed training, and cloud jobs.

Parse

Readable indentation-aware parser emits typed dataclass AST nodes.

Validate

Semantic checks catch missing blocks, unknown references, unsupported layers, and bad ranges.

Generate

PyTorch backend writes imports, loaders, model class, loop, metrics, export, and main.

Train

The CLI compiles and executes the generated script with the project Python runtime.

Proof, not theater

The first milestone is executable.

`kynml train examples/house_price.kyn` parses the source, validates the program, generates Python, trains a model on sample CSV data, prints metrics, and exports a Torch `state_dict`.

$ kynml validate examples/house_price.kyn
Valid KynML program: examples/house_price.kyn

$ kynml schema examples/house_price.kyn
HouseData | 20 rows | 10 encoded features | input 10

$ kynml compile examples/house_price.kyn --out generated/house_price.py --check-data
Generated generated/house_price.py

$ kynml train examples/house_price.kyn
Epoch 20/20 - loss: ...
mae: ...
rmse: ...
Saved model to models/house_price_model.pt

Capability matrix

A compact surface that can grow without collapsing.

Layers

Input + dense layers. Activations: relu, sigmoid, tanh, linear. Softmax output inferred from cross_entropy loss.

Losses

mse · bce · cross_entropy — covers regression, binary and multiclass classification.

Optimizers

adam(lr) · sgd(lr, momentum) with per-param learning rate. Scheduler: cosine_annealing.

Metrics

mae · mse · rmse · accuracy — computed on the held-out test split after training.

Export formats

torch state_dict .pt and onnx .onnx — both with automatic directory creation.

CLI commands

validate · ast · compile · train · sweep · compare · schema · fmt · lsp — nine commands for local compiler workflows.

Schema preflight

kynml schema and --check-data catch missing CSV files, target drift, feature-width mismatch, and bad class labels before generated PyTorch runs.

Performance

One line to unlock AMP, compile, and workers.

The compiler emits opt-in flags for PyTorch 2 torch.compile, mixed-precision AMP, and multi-worker data loading. No boilerplate edits — just set the flag in the train block.

AMP device = cuda

Emits autocast + GradScaler when CUDA is available. Half-precision training at full fidelity.

compile compile = true

Wraps the model in torch.compile() for PyTorch 2 graph capture and kernel fusion.

workers workers = 4

Passes num_workers to the DataLoader for parallel data prefetch, keeping the GPU fed.

Connectivity

Serve, orchestrate, integrate — without touching the compiler.

The optional kynml.serving, kynml.mcp, and kynml.integrations packages extend the base compiler into production workflows. Heavy deps are lazy-imported so the core package stays minimal.

01 REST serving

Service generator

Compiles a .kyn spec into a FastAPI service with /predict and /health endpoints through the kynml.serving package.

from kynml.serving import generate_service

02 MCP server

MCP package

Exposes KynML tools over the Model Context Protocol so MCP-compatible agents can validate, compile, and trigger training runs programmatically.

python -m kynml.mcp.server

03 HuggingFace

HF datasets

Pull any HuggingFace dataset directly into a .kyn pipeline with source = hf("dataset/name"). The integration handles splits, column mapping, and tensor conversion.

from kynml.integrations.huggingface import load_hf_dataset

SaaS operating layer

From local compiler to governed training workspace.

The shipped CLI is the kernel. The SaaS layer wraps it with project workspaces, data-contract gates, reproducible run records, API generation, and a clear path to cloud jobs without losing source-level reviewability.

01 spec.kyn committed

02 schema gate passed

03 pytorch build emitted

04 run manifest archived

Workspace specs

Teams version `.kyn` files as product assets: readable, diffable, formatted, and safe to review before training code exists.

Data contract gates

kynml schema becomes the pre-deploy check for targets, encoded feature width, label ranges, and CSV drift.

Run ledger

Generated scripts already write manifests with config hash, data hash, seed, environment, and metrics for audit-grade replay.

API path

Serving and MCP packages make the same compiler surface available to apps, agents, notebooks, and future hosted jobs.

Competitive map

Not another wrapper. A training language that can sit above the stack.

Lightning strengthens PyTorch projects. Keras gives a refined Python API. Ludwig pushes low-code breadth. ZenML orchestrates MLOps pipelines. KynML takes a sharper lane: compiler-checked training intent that emits readable Python and PyTorch.

kynml compare --format markdown

Tool Best at KynML edge

PyTorch Lightning Trainer, callbacks, accelerators, distributed runs Source-first training specs before boilerplate exists

Keras Human-friendly Python API and backend portability Reviewable DSL, deterministic codegen, explicit compiler boundary

Ludwig Declarative low-code breadth and production integrations Smaller language surface with syntax, IR, linting, and diffs

ZenML Pipeline orchestration, stacks, artifacts, and MLOps governance Compiler layer ZenML-like systems can orchestrate

Leadership

Built by operators who have shipped the stack before.

KynML is led from the HyperBridge Digital and Kynetra ecosystem: product narrative, AI architecture, platform engineering, and production delivery moving as one system.

KR

Founder & CEO

Supercharged entrepreneur and content producer. BE (CS), Anna University · 20 yrs. Architect of Kynetra AI — 423 regents across 25 domains. Fractional CMO to 200+ brands including Sony, Samsung, Tata Motors, HDFC, and GRT. Founded The Reel Factory.

Kynetra AI Brand systems 200+ brands

CS

Co-founder & CTO

BE (CS), Anna University · 22 yrs. Engineering force behind every HyperBridge platform. Owns the architecture across the Kynetra Cognitive Grid: telemetry, router, evaluator, memory, audit, prompts, and 30 production platforms.

Platform architecture AI infrastructure 30 platforms

Roadmap

From tabular PyTorch MVP to sovereign training substrate.

Phase 1 — shipped PyTorch transpiler, CSV datasets, dense models, regression + binary + multiclass, ONNX export, REST serving, MCP server, HuggingFace integration, 6-command CLI.

Phase 2 Image datasets, CNN layers, text datasets, transformer blocks, richer parser diagnostics, first-class remote source syntax.

Phase 3 TorchScript export, model registry, experiment tracking, generated script extension hooks.

Phase 4 JAX backend, MLIR backend, distributed training, cloud training jobs.

Phase 5 KynML Studio, AutoML layer, hosted SaaS workspaces, cloud training jobs, interactive compiler playground.