The Engine That Writes The OS.
Traditional "no-code" tools rely on slow, heavy runtime interpreters. Aeion OS rejects interpretation. At the kernel level lies the Universal Abstract Syntax Tree (AST) Compiler—a monumental code generation engine that translates visual logic graphs directly into highly optimized, zero-dependency source code across 30+ execution environments.
Infinite Compilation Targets
Frontend UI & 3D WebGL
The engine powers the Blueprint and Motion Studio modules. It compiles visual nodes into pure `TSX` (React hooks and Tailwind) for frontend interfaces, and raw WebGL2 `GLSL` / WebGPU `WGSL` strings for 60fps procedural 3D materials.
Cyber-Physical Manufacturing
Bridging bits to atoms. The SCM module utilizes the AST Engine to compile 5-axis visual kinematic nodes directly into physical **RS-274 G-Code**, allowing the OS to stream raw manufacturing instructions instantly to industrial CNC routers and sorting robots.
Post-Quantum Cryptography
Future-proof security. Sentinel researchers visually drag Hadamard and CNOT gates onto a canvas. The AST compiles this subatomic logic into raw **OpenQASM 2.0** and IBM Qiskit Python code to simulate true quantum-secure encryption natively.
Kernel-Level eBPF Firewalls
Visual threat hunting. Network analysts build threat matrix rules visually. The compiler translates this into highly optimized raw C code, invokes `clang`, and drops it directly into the Linux Kernel's XDP hook point via eBPF, dropping malicious DDoS packets in nanoseconds with zero CPU overhead.
IoT Over-The-Air Flashing
Smart Spaces relies on the AST to orchestrate physical hardware. Connect "DHT22 Sensor" and "MQTT Push" nodes visually; the engine compiles a hyper-stable `main.py` **MicroPython** payload and flashes it to ESP32 fleets over-the-air.
Zero-Knowledge Proofs (ZK)
For trustless legal compliance, the AST translates visual logical constraints into raw **Circom** circuit logic, generating the WebAssembly artifacts required to produce cryptographically secure zk-SNARK proofs instantly.
The Meta-Compiler
Zero Runtime Overhead
Because the AST compiles logic into the native target language (C, GLSL, TSX, Python) prior to execution, there is absolutely zero "interpreter" penalty. The output executes precisely as fast as hand-written code by a senior engineer.
TipTap "Living Documents"
The AST engine is embedded into the core text editor. Type `/xdp` or `/shader` inside a standard wiki document to mount an interactive AST canvas inline. An engineer can build and execute a database migration pipeline directly from the text of a Standard Operating Procedure (SOP).
All 31 Generators of Compilation Targets
MicroPython Generator
Turns a sensor/IoT graph into a MicroPython payload and flashes it straight to ESP32 / ESP8266 fleets over-the-air.
React Native Generator
Converts a screen design into an SDUI schema that Mobile Builder's on-device runtime renders as native React Native.
Infrastructure-as-Code Generator
Compiles a visual infrastructure diagram into Terraform HCL and Pulumi TypeScript, ready to provision VPCs, IAM, and databases.
Digital Twin Generator
Produces OPC UA and AAS shells for industrial digital-twin simulation from a visual process model.
Optimization Generator
Emits OR-Tools CP-SAT models for vehicle routing, scheduling, and bin-packing problems.
Nextflow Generator
Outputs Nextflow DSL2 pipelines for bioinformatics and scientific compute workloads.
WebRTC Mesh Generator
Generates WebRTC signaling and ICE negotiation code for peer-to-peer mesh networks.
Audio Worklet Generator
Compiles an audio-processing graph into an AudioWorkletProcessor for low-latency Web Audio DSP.
WebGPU Compute Generator
Turns a compute graph into WGSL shaders that run in parallel on the GPU.
Multiplayer Netcode Generator
Produces authoritative-server, client-prediction, and rollback netcode from a single gameplay graph.
eBPF Filter Generator
Compiles visual threat-hunting rules into raw C source, builds it, and loads it at the Linux kernel's XDP hook — dropping malicious traffic in nanoseconds with zero CPU overhead.
G-Code Generator
Converts 5-axis kinematic nodes into RS-274 G-Code that streams directly to CNC routers and 3D printers.
MAVLink Generator
Emits the MAVLink mission protocol for autonomous drone fleets.
Quantum Circuit Generator
Translates a gate-level graph (Hadamard, CNOT, and friends) into OpenQASM 2.0 and Qiskit Python for quantum-circuit simulation.
Smart Home Generator
Generates HomeAssistant YAML and Matter/Zigbee device configs from a visual automation graph.
SCADA Generator
Produces SCADA HMI screens for industrial control rooms.
Show Control Generator
Outputs DMX-512, Art-Net, and OSC cues for theatrical and event lighting.
Solidity Generator
Compiles a contract graph into Solidity smart contracts (ERC-20, ERC-721, or custom).
Zero-Knowledge Generator
Turns visual logical constraints into Circom circuits and the WebAssembly artifacts needed for zk-SNARK proofs.
Video FX Generator
Emits FFmpeg filter graphs for batch video processing.
WebAssembly Generator
Compiles to WebAssembly Text Format for sandboxed, portable execution anywhere WASM runs.
Neural Network Generator
Produces PyTorch and ONNX model definitions for ML training pipelines.
Physics Logic Generator
Generates physics constraints for 3D scenes.
OCR Template Generator
Builds document-extraction templates for the Files module's OCR pipeline.
Nano Engine Generator
Compiles a lightweight game-engine schema for interactive Spatial scenes.
IFC Generator
Produces an IFC building information model for the Construction module.
XBRL Generator
Generates XBRL filings for SEC / EDGAR financial reporting.
Meta-Compiler Generator
A generator that writes new generators — the extensible layer that lets teams add their own targets.
React Component Generator
Compiles a UI graph into pure TSX, Tailwind classes, and hooks for the Visual Editor and Blueprint.
FFmpeg Generator
Emits FFmpeg CLI command graphs for transcoding pipelines.
TypeScript ETL Generator
Produces typed ETL transformer functions for the Singularity module.
Mobile Builder SDUI — AST Compiled at the Edge
The Mobile Builder doesn't ship its own runtime interpreter to the device. Instead, screen designs built in the Visual Canvas are stored as ASTs, and the React Native Generator compiles each one into a JSON component-tree schema. The Expo runtime on the device reads that schema and renders native React Native components.
End-to-end flow:
- Designer drags components in the Mobile Builder canvas.
- Canvas serializes the screen as an AST (the same node format the visual scripting engine uses).
- The React Native Generator compiles the AST into an SDUI schema (component IDs, props, data bindings, children).
- The SDUI schema is versioned and stored, keyed by app and version.
- The device fetches the latest schema at app launch.
- Expo runtime walks the schema, mounts the corresponding native component, binds the data, and renders.
Result: No JavaScript interpreter on the device for the screen logic. The schema describes what to mount; the device's React Native runtime executes it natively. OTA updates ship a new schema, not new code.
This is why Aeion's Mobile Builder claims to ship "true native apps" — the AST compilation happens server-side, the device just hydrates the result.
Blueprint — Visual Workflows Compiled to TypeScript
Blueprint is Aeion's visual workflow engine. Users drag trigger / action / condition nodes onto a canvas; the AST engine compiles the resulting graph to executable TypeScript that runs in the workflow worker pool.
Every workflow benefits from the same underlying platform: 200+ pre-built templates to start from, an AI Copilot that turns a plain-language request ("build a workflow that...") straight into a working graph, iterative natural-language refinement to adjust a workflow after the fact, and full version history with diff and one-click rollback on every change.
Trigger sources the compiler emits handlers for: HTTP request, CRON schedule, internal event bus, webhook, manual trigger, AI agent, schedule, file upload, form submission.
Action targets: REST call, GraphQL query, MCP tool invocation, send notification, run code (in QuickJS sandbox), invoke another workflow, write to collection, modify role, send invoice, send SMS, post to Slack, call ChatGPT/Claude/local LLM, etc.
Compiled output is straightforward TypeScript with proper type safety + Aeion's RBAC enforcement. Runs in the same execution environment as hand-written modules. No interpreter penalty.
Why Compile Instead of Interpret?
The choice between "compile the visual logic to native code" vs "interpret the visual logic at runtime" has profound consequences:
Performance. A compiled React component runs at React's natural speed. An interpreted visual-logic VM adds 5-10x overhead per render. For a list of 1,000 items at 60 fps, the difference is glide vs stutter.
Debuggability. Compiled output is readable code. A senior engineer can open the generated TypeScript / GLSL / G-Code / Solidity and review it like hand-written code. Interpreted runtimes are black boxes — when something goes wrong, you debug the interpreter, not the logic.
Portability. Compiled output runs anywhere the target language runs. The G-Code from GCodeGenerator runs on ANY G-Code-compatible CNC, not just Aeion-aware ones. The OpenQASM from QuantumCircuitGenerator runs on IBM Q + Rigetti + AWS Braket — anywhere standard-compatible.
Versioning. Compiled output is plain text — diffable, versionable, code-reviewable. Workflow updates can go through standard git PRs alongside hand-written code. Interpreted state lives in a database with no diff semantics.
Sandboxing. Compiled WebAssembly runs in a real WASM sandbox with strict memory + capability boundaries. Interpreted bytecode runs in whatever sandbox the interpreter built (typically weaker).
No vendor lock-in. A team that builds visual workflows on Aeion and later migrates can take the compiled TypeScript with them. The IP is the source — they don't lose anything to Aeion's specific runtime.
The Extensibility Surface
A minimal generator contract
Implementing a new target means writing one small function that takes a visual AST and returns generated code (plus optional binary artifacts). Register it, and the canvas surfaces your new generator alongside the built-in 31.
Custom node libraries
Define new node types with typed input/output ports + serialization. Nodes can be marked compatible with specific generators (e.g., "this node only compiles to G-Code"). The canvas grays out incompatible combinations.
Meta-Compiler Generator
This generator generates generators. Useful for domain-specific languages — describe a DSL grammar visually, and the meta-compiler emits a ready-to-register generator implementation.
AI-generated nodes
Connect a new device with a published API spec; the AI Copilot generates a node + the matching generator code in one shot. Common pattern: "I need to control this brand of laser cutter" → 30 min later you have a working visual node.
Cross-generator references
A node in a Blueprint workflow can invoke a G-Code program generated elsewhere — references are typed + resolved at compile time, so you get type-safety across language boundaries.
Frequently Asked Questions
Zapier interprets your workflow on their servers — every action is a round-trip to Zapier's runtime. Aeion **compiles** your workflow into your own TypeScript module that runs in your own infrastructure. Performance is 10-100x better, debuggability is full (it's just code), and you can take the compiled output with you if you ever migrate. Zapier and Make are interpreters; Aeion is a compiler.
Yes — every generator's output is readable target-language source code (TypeScript, GLSL, C, Python, Solidity, etc.). The "Inspect Output" button in the canvas shows you the exact code that will run. Senior engineers often start with the visual canvas to scaffold + then commit the generated code to git for fine-tuning.
Two modes. **Round-trip:** the generator preserves a comment header in the output (`// @aeion-ast: <hash>`); when you re-open in the visual canvas, manual edits are preserved if they don't conflict with the AST structure. **Detached:** delete the header → the output is now hand-maintained code, and the canvas no longer owns it.
Yes — generators publish to a tenant-scoped registry. The "Generator Marketplace" view shows available generators (built-in + tenant-contributed). Enterprise tier supports publishing generators across tenants (e.g., a manufacturing consultancy publishes G-Code generators their clients reuse).
Describe the target output ("compile to OpenSCAD for 3D printing") + a few example AST → output pairs. The Copilot generates the `Generator` implementation. Often 80% of the work in 30 minutes; the team finishes the edge cases. For domain experts who can describe their target language but don't want to hand-roll the compiler.
Yes — the AST nodes carry typed input/output ports. When a Blueprint workflow node outputs a value that feeds into a G-Code node's input, the compiler verifies type compatibility at compile time + emits a marshalling step if needed (e.g., float → 4-decimal string for G-Code precision). Type errors surface in the canvas before you can save the AST.
First execution after deploy compiles the AST → caches the generated TypeScript on disk. Subsequent executions load from cache (microsecond cost). Workflows updated via the canvas trigger a recompile + cache invalidation. End-to-end p99 from "save in canvas" to "first execution runs new code" is under 5 seconds.
Yes — every AST change is tracked automatically with diff semantics, branching, and rollback. You can branch off main, iterate on a feature workflow, A/B test against the live version, and merge back. Pull-request-style review available on Pro+.