Projectured.jl

The released packages of ProjecturEd, a projectional editor: the data is the source, and every view is computed from it. Each folder is one package. The release of ProjecturEd writes this repository from projectured-julia, so a change belongs there.

Install

The packages are in the registry ProjecturedRegistry. Add General too, for the packages that they depend on. If General is there already, the line does nothing.

pkg> registry add General
pkg> registry add https://github.com/projectured/ProjecturedRegistry

Each package installs only what it needs. Add each package that you use by its name. A using line reaches only the packages that you added, so add the packages of other authors that you load too.

Use

To install and to load are two different steps. You can load in two ways.

Let Projectured load the integrations

pkg> add Projectured ProjecturedSDL ProjecturedDataFrames DataFrames SimpleDirectMediaLayer

julia> using Projectured, DataFrames, SimpleDirectMediaLayer
julia> display_in_editor(DataFrame(n = 1:100_000, square = (1:100_000) .^ 2))

The first using after an install compiles the packages, which takes a few minutes. After that, a session loads them in a second or two, and its first display_in_editor opens the window in about a second: each package holds the compiled code of its first window.

using Projectured loads the kernel, the platform and AutoIntegration. AutoIntegration loads a package that you installed when all its triggers are loaded. The order of the using lines does not matter. Each domain, the console, PDF and the model adapters load when Projectured is loaded. An integration loads when the package that it joins is loaded too:

Integration	It joins	It loads when these are loaded
ProjecturedDataFrames	DataFrames	Projectured and DataFrames
ProjecturedMCP	ModelContextProtocol	Projectured and ModelContextProtocol
ProjecturedODBC	ODBC	Projectured and ODBC
ProjecturedSDL	SimpleDirectMediaLayer	Projectured and SimpleDirectMediaLayer
ProjecturedTulip	Tulip	Projectured and Tulip
ProjecturedVideo	FFMPEG	Projectured and FFMPEG

A package that loads in this way puts no name into Main. To write SdlBackend(), add using ProjecturedSDL.

Name each package

pkg> add ProjecturedSDL ProjecturedDataFrames DataFrames

julia> using DataFrames, ProjecturedSDL, ProjecturedDataFrames
julia> display_in_editor(DataFrame(n = 1:100_000, square = (1:100_000) .^ 2))

The session loads the packages that you name and the packages that they depend on. Nothing else loads. ProjecturedDataFrames brings DataFrames as its own dependency, but a using line reaches only a package that you added by name, so the add line names DataFrames too: without it, using DataFrames fails with "Package DataFrames not found in current path".

Choose for each package

Each package says if it loads by itself. You can change it for each package in the file LocalPreferences.toml beside the Project.toml of your environment:

[AutoIntegration]
ProjecturedSDL = "auto"
ProjecturedDataFrames = "manual"

"auto" loads the package when its triggers are loaded. "manual" loads it only when you name it. A package with no line keeps its own default. This call writes the same line, after you add AutoIntegration by name:

pkg> add AutoIntegration

julia> using AutoIntegration
julia> set_auto_integration!("ProjecturedDataFrames", :manual)

Load all integrations

pkg> add ProjecturedIntegrations DataFrames SimpleDirectMediaLayer

julia> using ProjecturedIntegrations, DataFrames, SimpleDirectMediaLayer

ProjecturedIntegrations installs every integration and every package that they join. It loads an integration when the package that it joins is loaded, whatever LocalPreferences.toml says. Use it when you want all of them and do not want to choose.

Why there are so many packages

ProjecturEd joins many packages of other authors, and each join is one small package. Pkg installs all dependencies of a package and has no optional ones. So each integration is its own package, and you install only the ones that you add. Some users want the integrations to load by themselves, and some users name each package. The setting for each package lets you choose.

Which repository is which

Repository	What it is
projectured-julia	The source: the application, the examples, the tests and the guides. A change belongs there.
Projectured.jl	This repository: the released packages, which the release writes from projectured-julia.
ProjecturedRegistry	The Julia registry that names each version of these packages.
AutoIntegration.jl	The package that loads an installed package when its triggers are loaded. Projectured depends on it.
AgentClientProtocol.jl	The Agent Client Protocol (ACP) in Julia, for a client and for an agent. ProjecturedACP depends on it.
ClaudeCodeACP.jl	An ACP agent that runs Claude Code. ProjecturedACP runs it as its built-in agent.
ModelContextProtocol.jl	A fork of the Model Context Protocol (MCP) package of JuliaSMLM, which gives a tool handler the _meta of its request. ProjecturedMCP depends on it.

The packages

Package	Tests	What it holds or does
Projectured		The umbrella package of ProjecturEd: it loads the kernel, the platform and AutoIntegration, and gives the names that most users call.
ProjecturedKernel		The core of ProjecturEd: reactive cells, documents, references, operations, projections and the editor loop, with no concrete kind of data.
ProjecturedPlatform		What every kind of data shares: text, syntax, graphics, layout, widgets, panes, windows, the generic views and the application.
ProjecturedIntegrations		Installs every integration of ProjecturEd and the packages that they join, and loads each integration when the package that it joins is loaded.
ProjecturedAll		Every package of ProjecturEd that needs no package of another author, with all their names in one namespace. It loads much more than most programs need.
ProjecturedACP		Lets the AI assistant of ProjecturEd talk to an agent that runs its own loop, such as Claude, over the Agent Client Protocol (ACP).
ProjecturedAnthropic		Runs the AI assistant of ProjecturEd with a Claude model, through the Anthropic API.
ProjecturedBook		Structured prose: a book, its chapters, paragraphs of styled text, lists and pictures.
ProjecturedChart		Line, scatter, bar, histogram and strip charts as documents, drawn with no plotting library.
ProjecturedConsole		Shows the editor in a terminal with ANSI colours, and reads the keys of the terminal.
ProjecturedDBCatalog		The catalog of a database as a tree of documents: its tables and their columns.
ProjecturedDataFrames		Shows a DataFrame of DataFrames.jl as a table that you can scroll, sort, filter and edit, while the data stays in the data frame.
ProjecturedDatabase		The interface of a database adapter, and the documents of a database connection.
ProjecturedFSM		Extended state machines: states, transitions on events, timers or conditions, and variables. A machine draws as a live diagram and generates a Julia module.
ProjecturedFormula		Named formulas that refer to each other and compute a value, as the cells of a spreadsheet do.
ProjecturedGraph		Node-and-edge diagrams in which each vertex holds a document of any kind.
ProjecturedJSON		JSON data as a tree of documents that you edit in the JSON notation.
ProjecturedJulia		Julia source code as a tree of documents that you edit in the Julia notation.
ProjecturedLanguageServer		Colours the names of a C or C++ file by their kinds, which a language server such as clangd gives.
ProjecturedMCP		Lets a client outside the process, such as an AI assistant, drive a running editor over the Model Context Protocol (MCP).
ProjecturedMarkdown		A Markdown page as a tree of blocks and inlines.
ProjecturedMath		A math formula as a tree of documents: its structure, not its picture and not its value.
ProjecturedODBC		Connects the database documents to a live database through ODBC.jl, and runs its queries.
ProjecturedOllama		Runs the AI assistant of ProjecturEd with a model on your own machine, through a local Ollama server.
ProjecturedOpenRouter		A relevance model for the search of the AI assistant, which asks a model through the API of OpenRouter.
ProjecturedPDF		Writes a view as a vector PDF with selectable text, with no third-party package.
ProjecturedPivot		A table cut into parts by the values of its dimensions, as nested row and column headers, with a view of each part in its cell.
ProjecturedProcess		An algorithm as a structured flowchart: steps, decisions, loops and jumps. It runs with breakpoints and a live trace.
ProjecturedRST		reStructuredText as a tree of documents, with a parser and two presentations.
ProjecturedResearch		The record of a study: questions, sources, hypotheses, experiments, analyses, results, evidence, decisions and answers, each with who made it and when.
ProjecturedSDL		Shows the editor in native windows with SDL2, and writes images of a view.
ProjecturedSQL		A SQL statement as a tree of clause and expression documents, with a parser.
ProjecturedSequenceChart		Sequence charts: lanes of occurrences with arrows between them, which show what happened where, in which order, and what caused what.
ProjecturedTulip		Solves the relations of a constraint layout with the linear-programming solver Tulip.jl.
ProjecturedVideo		Records a scripted editing session as an .mp4 file, with no window.
ProjecturedWeb		Shows the editor in a web browser, through an HTTP and WebSocket server.
ProjecturedWorkflow		The record of a piece of work: steps, decisions and their options, a dated journal on each, and cards that show documents of any kind.
ProjecturedXML		An XML document as a tree of elements, text nodes and attributes.
ProjecturedYAML		YAML data as the tree of scalars, sequences and mappings that the JSON domain uses.

Tests

Each package holds its tests in test/. Each package with tests has a workflow of its own in .github/workflows, <Package>.yml, which runs them on every push, on Julia 1.12; its badge is in the table above.

Licence

The Mozilla Public License 2.0, in LICENSE.