Skip to main content
Yukta is a multi-module Gradle build. Each module has one job, and the pages in this tab explain how that job is done: what the module is for, its components and scenarios, what it guarantees and where the guarantee stops, and the decisions behind its design.
Yukta is pre-beta. Module internals change faster than the user-facing pages in the rest of this site.

​
The modules

​
How they fit together

Clients talk to web, mcp or ui, which translate requests into calls on core. The engine runs each node by calling a plugin through the contracts in plugin-api. State goes to the stores in core (files or memory) or persistence-postgres, and nodes can run on other machines through workers. boot wires everything into one application.

​
Where to start

Core reference

The feature catalogue, configuration properties, metrics and guarantees of the engine.

Core module

Components, scenarios and design decisions of the engine.

Writing a plugin

How to add a node type, with the plugin-api contracts explained.

Build and quality gates

What ./gradlew check runs, where, and why a pull request builds only changed modules.

​
Reading a module page

Every module page follows the same shape:
  1. At a glance and Primer. The problem the module solves, the vocabulary, and one example traced end to end.
  2. Components and Scenarios. The parts of the module and what happens inside them in typical and failing cases.
  3. Capabilities. What the module does, with its guarantee and limit for each capability.
  4. Guarantees and limits and Reference. What is enforced, what is only advice, what survives a restart, and the settings and lists behind them.
  5. Architecture decisions and Glossary. Why it is built this way, and what each term means.
Known weaknesses, confirmed defects and the plan for each module are kept on internal pages that need a sign-in: Risks, Bugs and Improvements in the Internal tab.