← Home На главную Inicio 首页

Docs / EngineDocs / EngineDocs / EngineDocs / Engine

ComponentComponentComponentComponent

A Component is the native executable the Engine emits from an operator-authored construct.wasm. The platform does not ship, store, or supply Components.Component — это нативный исполняемый файл, который Engine собирает из construct.wasm, написанного оператором. Платформа не поставляет, не хранит и не выдаёт Components.Un Component es el ejecutable nativo que el Engine emite a partir de un construct.wasm escrito por el operador. La plataforma no incluye, no almacena y no entrega Components.Component 是 Engine 根据操作员编写的 construct.wasm 生成的原生可执行文件。平台不附带、不存储、也不提供 Component。

What a Component is

A Component is the native executable produced for one operating system and one architecture. It is the output of a build. It is not a file that ships inside Cyberspace.

The platform does not include Components, does not keep a library of them, and does not hand them out. The operator Client and Autofac are delivered without any Component image.

What you author

You write a Construct: a freestanding program compiled to construct.wasm (wasm32, no hosted operating system). Any language that can emit that module is suitable — C, C++, Rust, Zig, and other compilers that follow the same contract. The source and the wasm stay with you.

The guest exports a small host interface (init, collect_meta, exec_task, malloc, free). It does not open operating-system sockets or files itself. Autofac is reached through that interface.

What the Engine does

The Engine is the ahead-of-time compiler of the platform. It reads the wasm intermediate form and writes a native image for the ABI and instruction set you select.

  1. In the Client, load your construct.wasm.
  2. The Client sends that module to Autofac.
  3. Autofac binds the session control data for the chosen operating system and architecture, then emits the Component.
  4. The result is a small native executable. The wasm is the input. The Component is what the Engine returns.
construct.wasm  →  Client  →  Autofac Engine  →  Component

The guest itself stays platform-independent. Windows, Linux, and macOS — and the other profiles the Engine knows — are chosen in the Client, not compiled into the wasm.

What the license download contains

The download page provides the operator Client and Autofac. It does not provide Components. A Component exists only after the Engine has built one from your own Construct.

Что такое Component

Component — нативный исполняемый файл под одну операционную систему и одну архитектуру. Это результат сборки, а не файл, который входит в поставку Cyberspace.

Платформа не содержит Components, не хранит их библиотеку и не выдаёт их. Операторский Client и Autofac поставляются без какого-либо образа Component.

Что пишете вы

Вы создаёте Construct: freestanding-программу, собранную в construct.wasm (wasm32, без hosted-операционной системы). Подходит любой язык, который умеет выдать такой модуль — C, C++, Rust, Zig и другие компиляторы с тем же контрактом. Исходники и wasm остаются у вас.

Гость экспортирует небольшой интерфейс хоста (init, collect_meta, exec_task, malloc, free). Сокеты и файлы операционной системы он сам не открывает. К Autofac обращение идёт через этот интерфейс.

Что делает Engine

Engine — это ahead-of-time компилятор платформы. Он читает промежуточную форму wasm и записывает нативный образ под выбранные ABI и набор команд.

  1. В Client загружаете свой construct.wasm.
  2. Client отправляет этот модуль на Autofac.
  3. Autofac привязывает данные управления сессией к выбранной операционной системе и архитектуре и выпускает Component.
  4. На выходе — небольшой нативный исполняемый файл. Wasm — вход. Component — то, что возвращает Engine.
construct.wasm  →  Client  →  Autofac Engine  →  Component

Сам гость остаётся независимым от платформы. Windows, Linux и macOS — и остальные профили, которые знает Engine — выбираются в Client, а не зашиваются в wasm.

Что входит в загрузку по лицензии

Страница загрузки отдаёт операторский Client и Autofac. Components она не отдаёт. Component появляется только после того, как Engine собрал его из вашего собственного Construct.

Qué es un Component

Un Component es el ejecutable nativo producido para un sistema operativo y una arquitectura. Es el resultado de una compilación. No es un archivo que viaje dentro de Cyberspace.

La plataforma no incluye Components, no guarda una biblioteca de ellos y no los entrega. El Client del operador y Autofac se distribuyen sin ninguna imagen de Component.

Qué escribe usted

Usted crea un Construct: un programa freestanding compilado a construct.wasm (wasm32, sin sistema operativo hosted). Sirve cualquier lenguaje capaz de emitir ese módulo — C, C++, Rust, Zig y otros compiladores con el mismo contrato. El fuente y el wasm se quedan con usted.

El guest exporta una interfaz de host pequeña (init, collect_meta, exec_task, malloc, free). No abre por sí mismo sockets ni archivos del sistema operativo. Autofac se alcanza a través de esa interfaz.

Qué hace el Engine

El Engine es el compilador ahead-of-time de la plataforma. Lee la forma intermedia wasm y escribe una imagen nativa para el ABI y el conjunto de instrucciones elegidos.

  1. En el Client, cargue su construct.wasm.
  2. El Client envía ese módulo a Autofac.
  3. Autofac vincula los datos de control de la sesión al sistema operativo y a la arquitectura elegidos, y emite el Component.
  4. El resultado es un ejecutable nativo pequeño. El wasm es la entrada. El Component es lo que devuelve el Engine.
construct.wasm  →  Client  →  Autofac Engine  →  Component

El guest sigue siendo independiente de la plataforma. Windows, Linux y macOS — y los demás perfiles que conoce el Engine — se eligen en el Client, no se compilan dentro del wasm.

Qué contiene la descarga de la licencia

La página de descarga entrega el Client del operador y Autofac. No entrega Components. Un Component existe solo después de que el Engine lo ha construido a partir de su propio Construct.

Component 是什么

Component 是针对一种操作系统和一种架构生成的原生可执行文件。它是一次构建的产物，不是随 Cyberspace 一起交付的文件。

平台不包含 Component，不保存它们的库，也不把它们发给任何人。操作员 Client 和 Autofac 在交付时不含任何 Component 镜像。

由您编写的部分

您编写 Construct：一个编译为 construct.wasm 的 freestanding 程序（wasm32，没有 hosted 操作系统）。任何能产出该模块的语言都可以——C、C++、Rust、Zig，以及遵循同一契约的其他编译器。源码和 wasm 留在您这边。

Guest 导出一个很小的宿主接口（init、collect_meta、exec_task、malloc、free）。它自己不打开操作系统的套接字或文件。与 Autofac 的通信通过这个接口完成。

Engine 做什么

Engine 是平台的 ahead-of-time 编译器。它读取 wasm 中间形式，并按您选择的 ABI 和指令集写出原生镜像。

  1. 在 Client 中加载您的 construct.wasm。
  2. Client 把该模块发给 Autofac。
  3. Autofac 按所选操作系统和架构绑定会话控制数据，然后发出 Component。
  4. 结果是一个体积很小的原生可执行文件。wasm 是输入。Component 是 Engine 的返回值。
construct.wasm  →  Client  →  Autofac Engine  →  Component

Guest 本身与平台无关。Windows、Linux 和 macOS——以及 Engine 认识的其他配置——在 Client 中选择，而不是编译进 wasm。

许可下载里有什么

下载页提供操作员 Client 和 Autofac。它不提供 Component。只有 Engine 根据您自己的 Construct 完成构建之后，Component 才存在。