Programming language integrations

Ten languages are available through seven provider families. Import a provider, write a Zolo signature, and keep the function body in its native language. These are integrations into the Zolo host, not compilation targets for those languages.

Preparation and deployment¶

Source-free packaging can retain prepared foreign artifacts, but does not remove runtime or platform dependencies. VM, native and LLVM hosting are covered; foreign bindings reject unsupported WebAssembly targets. The recent provider acceptance covers Windows x64. Python acceptance specifically covers CPython 3.12; other platforms need their own verification.

C#¶

Embed typed C# functions, CLR objects, callbacks and asynchronous calls. Prepare with the .NET tooling and retain the matching runtime when deploying.

use plugin dotnet::{csharp}

extern csharp fn add(a: int, b: int) -> int {
    return a + b;
}

Practice in By Example · Source program

Python¶

Run Python in process with native imports and typed conversion. Windows with CPython 3.12 is verified; a compatible interpreter and native package dependencies are required.

use plugin python::{python as py}

extern py fn add(a: int, b: int) -> int {
    # Braces in comments stay inside Python: } {
    return a + b
}

Practice in By Example · Source program

JavaScript / TypeScript¶

Use JavaScript and TypeScript through embedded Node, including native modules and Promises. The shim, runtime and addon ABI must match. Zolo int uses bigint in inline signatures.

use plugin node::{javascript as js, typescript as ts}

extern js fn add(a: int, b: int) -> int {
    return a + b;
}

Practice in By Example · Source program

Java / Kotlin¶

Share one JVM for Java and Kotlin, with native imports, live objects and Maven dependencies. Source and editor preparation need the matching tools; prepared applications need a compatible JRE. JVM 8, 11 and 23 are verified on Windows x64.

use plugin jvm::{kotlin}

extern kotlin fn greet(name: str) -> str {
    return "Olá, $name!"
}

Practice in By Example · Source program

C / C++¶

Prepare C17 and C++17 libraries with Clang. C++ exposes supported concrete classes; native ownership and unsupported pointers or templates require explicit adapters. Prepared code runs without the source compiler.

use plugin native::{cpp}

extern cpp fn greet(name: str) -> str {
    return "Hello " + name;
}

print(greet("Zolo"))

Practice in By Example · Source program

Rust¶

Compile typed Rust functions and copied records into a target-specific library. Cargo dependencies join the locked workflow. Deployed artifacts do not need rustc or source files; retained receiver objects and open generics need adapters.

use plugin rust::{rust}

extern rust fn exact(value: int) -> int {
    value
}

Practice in By Example · Source program

Go¶

Prepare Go exports with cgo and a compatible C compiler. Typed functions, copied public structs and modules use the common bridge. Prepared artifacts need neither Go nor the module cache; retained receivers and variadics require adapters.

use plugin go::{go}

extern go fn exact(value: int) -> int {
    return value
}

Practice in By Example · Source program

Types across the boundary¶

Types across the boundary · Dependencies and locks