Product overview
Block is a local-first polyglot orchestration engine. It gives one file a clear way to coordinate multiple native runtimes, carry compatible state forward and expose execution as a sequence developers can understand.
ORCHESTRATORThe best language for a task should be a design choice—not an integration problem.
Software rarely lives inside one ecosystem. A data workflow may begin in Python, a transformation may be easiest in JavaScript, a local database may belong in SQLite, and a systems component may need Rust or Go. Conventional approaches force those choices into separate repositories, services and hand-written bridges.
Block treats them as stages of the same program. You describe the language boundaries explicitly; the orchestrator prepares each stage, launches the native runtime and carries compatible values into the next context. The result is a workflow that stays compact without pretending every language is identical.
Block is useful wherever a project benefits from more than one runtime but does not benefit from the operational weight of turning every boundary into a service.
Data pipelines
Use Python's mature analysis ecosystem to clean and enrich source data. Pass the result to SQLite for local querying or persistence, then let JavaScript shape a report, payload or interactive output. Each stage remains visible and ordered.
Automation
System automation often grows from a shell command into a PowerShell script, then gains a Python helper and a JavaScript formatter. Block gives that evolution a shared structure, so the operator runs one entry point while each language still uses its native strengths.
Backend prototypes
Prototype internal APIs, import jobs and local services around the packages that solve the problem fastest. A team can test data flow and behavior in one Block program, then decide which boundaries genuinely deserve independent services later.
AI and model tooling
Python can own preprocessing and inference while JavaScript, PHP or another runtime owns the surrounding application logic. Block coordinates the stages so experiments can grow into useful local tools without rewriting the model layer.
Developer tools
Create migration assistants, code generators, release helpers and focused command-line tools. Use one runtime for system access, another for parsing and another for output—then distribute the operation as one understandable Block project.
The orchestrator coordinates; it does not attempt to become Python, Node.js or PHP. Each runtime remains responsible for its own semantics and ecosystem.
C# ORCHESTRATORRouting / lifecycle / stateBlock reads the source file, identifies the declared runtime for each section and constructs an ordered execution plan.
Names and compatible values are sanitized and encoded before they move between execution contexts.
The engine calls the actual runtime installed for that language, preserving familiar language behavior and library access.
Output and selected state return to the orchestrator, where the next declared stage can continue the program.
Shared state
Compatible values can move through Block's orchestration pipeline so each language stage can build on what came before. The transfer remains an explicit boundary: the engine prepares names and values for the destination context instead of pretending separate runtimes share one physical memory space.
This model is particularly useful for arrays, scalar values and structured workflow results. It reduces repetitive glue while preserving a sequential mental model: one stage produces, the orchestrator transfers, the next stage consumes.
Read the syntax guide →scores[]READYsummary{}READYelapsedREADYPolyglot execution introduces trust boundaries. Block makes those transitions a first-class part of the engine rather than leaving every project to invent its own string interpolation strategy.
Transferred text is prepared before it reaches a destination runtime, reducing the risk created by unsafe direct interpolation.
Variable identifiers pass through validation so generated destination scope does not become an uncontrolled code surface.
Each native interpreter runs as its own managed process, giving the orchestrator a clear lifecycle and input/output boundary.
Security is a system property. Block's transfer pipeline reduces common cross-runtime hazards, but projects should still validate untrusted inputs, review invoked code and follow the security guidance of every runtime they use.
Developer experience
Block keeps orchestration syntax intentionally compact. You spend less time learning framework-specific abstractions and more time writing ordinary code inside clear language blocks.
01Readable block delimitersLanguage boundaries are visible in source.
02Editor extensionsSyntax support for VS Code and Acode.
03Installer-assisted setupChoose an edition and configure the environment.
04Observable executionFollow startup, transfer and completion output.
All editions share Block's file model and orchestration philosophy. The difference is how far the available runtime matrix extends.
| Capability | Block LiteCompact | BlockStandard | Block+Expanded |
|---|---|---|---|
| Best for | Learning and lightweight scripting | Everyday polyglot workflows | Advanced tooling and systems work |
| Core runtimes | Python, JavaScript, HTML | Python, JS, PHP, Lua, SQLite | Standard plus Rust, Go, C++, Zig, Perl, PowerShell and more |
| Shared workflow | ● | ● | ● |
| Native process execution | ● | ● | ● |
| Dynamic state propagation | Essentials | Full scripting workflow | Advanced runtime matrix |
| Installer | Lightweight package | Guided setup | Winget-assisted setup |
| File extension | .blkl | .blk | .blkp |
Start with one file
Download Block, choose an edition and build your first orchestrated program.