Plugfy is an open source modular language. One source compiles to one typed IR and runs three ways — a portable .fy image, a native executable, or a direct script — so they can never diverge.
namespace hello // a capability: declared, visible, grantable host fn print(s: string) -> int fn main() -> int => print("Hello, Plugfy!")
$ plugfy build hello.plug -o hello.fy $ plugfy run hello.fy Hello, Plugfy!
Familiar where it should be, honest where it matters.
A compiled .fy image is typed bytecode plus a manifest — it runs on any OS or architecture the runtime is ported to. A Hello World is 126 bytes.
The runtime picks the fastest tier available — AOT native slices, JIT, or the VM — transparently. Optional native accelerators give machine-code speed per platform.
Reaching the outside world — files, network, clock, printing — is a declared capability. Effect rows are published in every module and enforced at run time, least-privilege by default.
Orchestration lives in the language. Pure steps parallelize automatically, and the parallel result is guaranteed identical to the sequential one — deterministic by construction.
The object model a C# or Java developer recognizes at once, with the safety of Kotlin and Swift and the honesty of Rust — one surface, one error model, one null model.
plugfy inspect shows what a module needs from the world — every function's capabilities — without executing a single instruction.
Plugfy organizes software the way organizations think: a domain, governed projects, business rules — compiled into portable, runnable artifacts.
The domain. Groups the projects that together solve one business problem.
Governance. Manifest, dependencies, targets and build outputs for one deliverable.
A module (.plug): types, functions, decisions — one namespace per file.
Orchestration (.flow): steps wired as a dependency graph, observable end to end.
The portable binary image (.fy) — AOT, JIT or VM, on Windows, Linux, macOS, iOS, Android and the web.
Write orchestration as data dependencies, not thread management. Pure steps with no host effects run in parallel automatically; effectful steps keep their source order. Results are assembled by source index, so the parallel result is byte-identical to the sequential one — pinned by a CI gate.
flow profile(xs: List<int>) -> Stats { total = sum(xs) // wave 0 — steps run in parallel avg = mean(xs) // wave 0 hi = maxOf(xs) // wave 0 => Stats(total: total, avg: avg, hi: hi) }
The two-layer model: a portable image that runs anywhere the runtime runs, optionally carrying per-platform native slices for native speed where they exist.
$ plugfy build app.plug -o app.fy # portable image $ plugfy build app.plug --native-slice --target win-x64,linux-x64 # + native accelerators $ plugfy native app.plug --target win-x64,linux-x64,osx-arm64 # standalone binaries $ plugfy run app.fy # auto-selects native / JIT / VM
Plugfy is free and open source, created and maintained by the Plugfy Foundation, a non-profit organization. The Foundation stewards the language specification, the compiler and runtime, the standard library, and the community that builds them.