<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Explanation on Itara</title><link>https://itara.dev/docs/explanation/</link><description>Recent content in Explanation on Itara</description><generator>Hugo</generator><language>en</language><atom:link href="https://itara.dev/docs/explanation/index.xml" rel="self" type="application/rss+xml"/><item><title>Vision</title><link>https://itara.dev/docs/explanation/vision/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://itara.dev/docs/explanation/vision/</guid><description>&lt;p&gt;This document describes where Itara is going, not just where it is. It is
a living document.&lt;/p&gt;
&lt;p&gt;Itara — the open-source specification and its reference implementations —
is the cornerstone of this vision, not the whole of it. Everything else on
this site describes what exists today, working, open source, and usable.
This page describes the future that today&amp;rsquo;s Itara is the first step
toward.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="the-north-star"&gt;The north star&lt;a class="td-heading-self-link" href="#the-north-star" aria-label="Heading self-link"&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;A production system should have a declared, validated, and executable
topology — how its components communicate and connect — that is easy to
change without touching business code, without migration ceremony, and
without downtime. And it should be able to do so safely: with the
confidence that the new topology is correct before it is applied, that
every connection is validated, and that nothing can be misconfigured
silently.&lt;/p&gt;</description></item><item><title>Architecture</title><link>https://itara.dev/docs/explanation/architecture/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://itara.dev/docs/explanation/architecture/</guid><description>&lt;p&gt;This page describes how Itara actually works today — the module
structure, the layering rules, what happens at startup, and what happens
on a call. For where this is going, see &lt;a href="https://itara.dev/docs/explanation/vision/"&gt;Vision&lt;/a&gt;. For the
formal, normative behavior every implementation must satisfy, see the
&lt;a href="https://itara.dev/docs/reference/wiring-configuration/"&gt;wiring configuration&lt;/a&gt; and
&lt;a href="https://itara.dev/docs/reference/metadata-format/"&gt;metadata format&lt;/a&gt; references.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="the-core-idea-in-one-paragraph"&gt;The core idea, in one paragraph&lt;a class="td-heading-self-link" href="#the-core-idea-in-one-paragraph" aria-label="Heading self-link"&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;The Itara agent runs before application code. It reads a wiring config,
loads the plugins that config actually requires, generates proxies and
listeners for each declared connection, and registers everything in the
component registry — before the application handles its first request.
By the time your entry point executes, the topology is fully wired.
Component code calls other components through plain interface
references and never knows whether the call goes in-process or across a
network — or which language the other component is written in. The
specification itself is language-neutral: a Java component and a Rust
component can participate in the same topology, wired by the same
config, producing a single distributed trace.&lt;/p&gt;</description></item></channel></rss>