Extend

One manifest holds extensions, skills and tools

Other editors can only add plugins. Textrix can also replace its core — seven stages, each one swappable.

Below is the settled extension model. The marketplace and core swapping open with the public release.

Two kinds

Two kinds of extension, not one

Adding gives the editor new capabilities; swapping replaces how one stage of the core works — the two stack, they do not replace each other.

Add · marketplace

Give the editor new capabilities

Panels, commands, languages, themes, editor modes, external tools — install a work and its capabilities show up in your library automatically. You never need to remember whether a feature came from a plugin or a skill.

  • Five categories: extensions / experts / skills / plugins / MCP
  • One place to discover them (the library)
  • Declared contribution points, in place once installed

Swap · replaceable core

Replace one stage of the core

The official build ships one default implementation per stage, with a public interface — from ingestion to export there are seven stages, and any of them can be replaced, including with something you keep to yourself.

  • Seven stages, each one swappable
  • Fixed interfaces and input/output schemas (hard contract)
  • Private use / free public / paid

One manifest

Four layers · one manifest

The word "plugin" spans two very different layers — a single manifest has to express all of them: entry points in the UI, capabilities in the editor, knowledge for the AI, and boundaries for code.

Textrix hostCOREeditorgraphfilesmanifest-declared, sandboxedplugin-aruns in a sandboxplugin-bruns in a sandboxplugin-cruns in a sandbox

① Contribution points

contributes

Activity bar, views, commands, menus, keybindings — how a capability appears in the UI so people can actually find it.

② Editor capabilities

editors

Custom editors, editor-core extensions, language services — so results land in the document, not just in a chat box.

③ Agent capabilities

agent

Skills (knowledge packs), tools (declarative or pointing at MCP), prompts and personas — what the AI does and what it uses.

④ Runtime

runtime

Sandbox, external processes, permission declarations — where code runs and what it may touch is written in the manifest, and granted on first use.

One manifest per extension (manifest.json): all four layers live in the same file — installed once, authorised once, discovered in one place.

Replaceable core

Seven stages, every one swappable

The core of Textrix is a seven-stage pipeline. The official build supplies defaults and publishes the interfaces; the interfaces between stages stay stable, so anyone can replace a stage.

  1. Ingest

    External content → a form we can process. Default: common document format conversion.

  2. Parse

    Text → a structured syntax tree. Default: CommonMark.

  3. Index

    Syntax tree → a searchable index. Default: full-text search plus vector index.

  4. Retrieve

    Query → relevant passages. Default: hybrid keyword and vector ranking.

  5. Reason

    Context → AI output. Default: official prompts plus the model you bring.

  6. Render

    Syntax tree → a view. Default: the editor and the renderers for each format.

  7. Export

    Syntax tree → a delivery format. Default: Word / PDF / HTML.

Compatibility

Three ecosystems, three different routes

Faced with three sources of extensions, Textrix does not build one compatibility layer to rule them all — each source takes the route that actually fits it.

VS Code extensions

API compatible · really runs

We implement the VS Code extension API, and extensions run in a separate extension host process talking to the main process. Commands, menus, language support, tree views, webviews and themes work directly.

  • Runs in an isolated process, activated on demand
  • API compatibility covers same-lineage extensions
  • Does not depend on the VS Code marketplace itself

Obsidian plugins

Data compatible · code does not run

We do not implement the Obsidian plugin API. Instead we open your vault directly (Markdown + frontmatter + [[wikilinks]]), and rebuild the capabilities of well-loved community plugins as built-ins or native extensions.

  • Zero-cost migration, no lock-in
  • A different editor core means plugin code does not transfer
  • Treat the community list as a requirements backlog, rebuilt one by one

Textrix native

One manifest

The same manifest describes all four layers, meeting the other two routes in one library — so users never need to know where a capability came from.

  • One manifest, four layers
  • One permission model
  • One place to discover everything

Ecosystem & business

How the ecosystem turns

Open publishing rights, developers who can earn, and a neutral platform in the middle — the platform never touches your money or your data, only discovery, distribution, review and adoption.

Private use

Keep it on your own machine: point at a directory containing a manifest and it loads. The platform never knows, and can never require you to publish.

Free and public

Publish for free and be paid back in reputation and citations — skills and connectors naturally belong here, and charging for them would kill the ecosystem.

Paid

Pricing and payment go through the developer’s own channel; the platform only records the price and handles discovery and update delivery — it never touches the user’s money.

The marketplace and core swapping open with the public release. Developers are welcome to write in about what you have in mind:[email protected]

FAQ

Extension model questions

Will VS Code extensions really run, or is that a promise?

The approach is settled: we implement the VS Code extension API and run extensions in a separate extension-host process — the same architecture VS Code itself uses. Compatibility work continues with the ecosystem as it grows.

Why will my Obsidian plugins not run as-is?

A different editor core means a different plugin runtime — their code cannot transfer. What does transfer is your data: we open your vault directly, so files, frontmatter and [[wikilinks]] carry over untouched, and we rebuild the capabilities of well-loved plugins as built-ins or native extensions.

Can one extension add UI and agent skills at the same time?

Yes — that is the point of the single manifest. All four layers (UI entries, editor capabilities, agent capabilities, runtime permissions) live in one manifest.json, so one install covers every layer it declares.

Can extensions see all of my files?

No. Extensions run in a sandbox and their permissions are declared in the manifest before you install. Runtime access is granted on first use — you can see what an extension asks for and decide each grant.

Related

Keep exploring

The ecosystem model has neighbours on every side.

Still in development

Downloads are not open yet. Join the waitlist and we will invite you the moment it opens.

Email-collection mode: submitting opens a pre-filled message in your mail client.