READING EDITION / RESEARCH PREVIEW

This is a static guide, not a live service status. Public remote writes and execution remain disabled. No JavaScript is needed to read this page.

Cursors Research Horizon: Videos, Papers, and Experiments

Status: curated research map. A citation means “worth studying,” not “Cursors already implements this” or “the source proves our design correct.”

This watchlist is arranged in three rings:

  1. Near horizon: directly informs current SQLite, Lua, causal, cockpit, and cryptofabric work.
  2. Middle horizon: supplies mechanisms that may become components or experiments.
  3. Far horizon: challenges the shape of Cursors itself.

The useful question for every source is:

Which invariant, smallest executable experiment, cockpit evidence, and possible false claim does this suggest?

21. Video sequence, rebuilt with direct links

1. Colin Breck: Predicting the Future of Distributed Systems

Watch for

Cursors use

This supports Cursors’ separation of portable semantic records from replaceable SQLite bodies, carriers, stores, and execution engines. The concrete experiment is one continuation that moves from browser SQLite to native SQLite to a remote semantic adapter without changing its cursor, state-root, grant, or receipt identity.

Danger

“Object storage becomes a database” must not become “put every operational row in a content-addressed DAG.” Local indexes, queues, leases, and caches remain operational state.

2. Tony Garnock-Jones: Syndicated Actors for Conversational Concurrency

Watch for

Cursors use

Cursor Logic relations, leased assertions, guide embeds, and causal-horizon projections should reuse this language. The smallest experiment is the watch-party continuation waiting on a structural interest, waking from one leased assertion, and explaining both why it resumed and why it had not resumed one horizon earlier.

Danger

A current assertion is not durable cursor history, and observing one does not confer authority to act.

3. Tudor Gîrba: Moldable Development, Programming Through Custom Tools

Watch for

Cursors use

The cockpit should provide cursor, authority, horizon, carrier, receipt, rule, and plan-specific lenses over the same underlying objects. Guides should embed these real lenses beneath the text.

Danger

A hundred custom views without one semantic object model becomes a museum of incompatible widgets. Cursor Terms, evidence classes, and stable subject IDs must remain shared.

4. Amy Ko: Debugging Reinvented, Why and Why Not

Watch for

Cursors use

WHY DID MIRROR RESUME C83? and WHY DID EMBER NOT RESUME C83? should be ordinary cockpit operations backed by derivation and causal edges. Why-not must expose failed prerequisites and open-world unknowns rather than manufacture a global falsehood.

Danger

A generated explanation is only as sound as the horizon, completeness policy, and provenance it cites.

5. Toby Ho: Introducing the Deep Zoom Debugger

Watch for

Cursors use

A causal cone can begin as one cursor and zoom through its parents, continuation state, derivations, authority presentation, state resolution, effect intent, and receipt without changing subjects or opening unrelated drawers.

Danger

Physical time, causal order, semantic nesting, and visual depth are different dimensions. Do not encode all four into one vertical axis.

6. Bret Victor: Inventing on Principle

Watch for

Cursors use

Guide-embedded cockpits, counterfactual horizons, and a live cryptofabric plan board should update from bounded edits immediately. A changed plan or rule creates an experimental branch, not an invisible mutation of canonical history.

Danger

Immediacy is not permission to skip validation, authority, durable commit, or receipt boundaries.

7. Oliver Flatt and collaborators: Better Together, Unifying Datalog and Equality Saturation

Watch for

Cursors use

Use egglog as a sidecar to explore equivalent cryptofabric plans, then independently verify the extracted candidate against authority, causality, transaction, curve, and receipt barriers.

Danger

Equality saturation is extremely good at proving the wrong equivalence compactly when the rewrite vocabulary omits an effect or trust boundary.

8. Max Willsey and collaborators: egg, Fast and Extensible Equality Saturation

Watch for

Cursors use

The cockpit should show alternative plans, the rewrites that produced them, multidimensional costs, and why the selected candidate won.

Danger

The cost model must not collapse privacy, authority, failure semantics, latency, bytes, and energy into one unexplained score.

9. Paul Chiusano: Unison, a New Distributed Programming Language

Watch for

Cursors use

Compare content-addressed code identities with Cursors’ continuation/program roots. Scheme and Lua implementations should be able to name the same immutable program IR while remaining different execution bodies.

Danger

Content-addressing a definition does not answer who may run it, with which resources, against which data, or whether its effects were accepted.

10. Leslie Lamport: Thinking Above the Code

Watch for

Cursors use

Every cursor operator, effect state, horizon transition, capability presentation, and plan barrier should have an explicit state-machine model and adversarial trace.

Danger

A correct high-level specification does not prove an implementation conforms. Model traces must feed executable fixtures and cockpit evidence.

11. Hillel Wayne: Everything About Distributed Systems Is Terrible

Watch for

Cursors use

Import TLA+ or explicit-state counterexamples as formal causal horizons, then inspect them through the same why/why-not and plan lenses as live traces.

Danger

Do not label a formal model trace as observed runtime evidence.

12. Martin Kleppmann: CRDTs, The Hard Parts

Watch for

Cursors use

Keep CRDTs for data types that truly need convergent replicated values. Use signed cursor history, explicit joins, receipts, and authority for execution and effects.

Danger

A converged value does not prove that an external action was authorized, executed, or observed.

13. Kenton Varda: No REST for Cap’n Web

Watch for

Cursors use

Cap’n Web is the live edge for MessagePort, HTTP batch, WebSocket, and WebRTC sessions. Signed cursors, grants, checkpoints, outbox rows, and receipts remain the durable boundary.

Danger

An RPC stub is session-local and ephemeral. It is not a durable cursor identity or portable capability record.

14. Colin Breck follow-on: Continuous Intelligence and Streaming Systems

Watch for

Cursors use

Treat cockpit instruments and guide embeds as projections over live evidence and durable history, not dashboards fed by one central telemetry store.

Danger

“Continuous intelligence” can become an excuse to blur observations, predictions, and authority. Preserve evidence class and source.

15. Strange and useful contrast: Orc, structured orchestration

Watch for

Cursors use

Compare Orc operators with Cursors sequence, split, join, race, retry, and exchange, then freeze the smallest operator set whose failure and receipt semantics remain explainable.

Danger

Orchestration operators alone do not solve durable identity, authority, carrier changes, or uncertain external effects.

Near-horizon papers

Cursor Logic, Datalog, and time

Experiment

Freeze one rule IR with Lua-table, S-expression, and Prolog-like renderings. Evaluate ancestor, candidate_resume, and missing_receipt from the same SQLite horizon in JavaScript and Nelua/Wasm.

Provenance and explanation

Experiment

For one effect receipt, store the rule derivation, cursor parentage, capability presentation, state-resolution evidence, body lease, submission, observation, and receipt as typed edges. Then ask why and why-not questions before and after removing one prerequisite in a simulated horizon.

Incremental relational engines

Experiment

Use the same Cell dependency and Cursor Logic workload to compare:

Publish row counts, deltas, memory, startup, crossings, and selected provenance. Avoid universal “fastest engine” claims, because that ritual has already consumed enough conference slides.

Middle-horizon mechanisms

Capabilities and caveats

Experiment

Represent caveats as Cursor Terms and evaluate them through Cursor Logic, but require a signed capability presentation before any effect gate. Add third-party discharge as a separate signed evidence relation.

Set reconciliation and recovery

Experiment

Expose three independent gauges:

knowledge rank       set difference discovery
recovery rank        immutable payload reconstruction
causal completeness  explanation evidence

The plan optimizer may choose minisketch, rateless IBLT, range reconciliation, exact fetch, or RaptorQ according to bounded inputs and measured conditions.

Mobility and durable execution

Experiment

Define the minimum portable continuation as:

program root
named program point
serializable locals
state roots
capability references
causal parents
required body profile

Resume it on two genuinely different bodies without serializing a VM heap, C stack, JS promise, or Cap’n Web stub.

Far-horizon work that may change Cursors

1. Bidirectional and relational programming

Study miniKanren, lenses, logic variables, and relational interpreters as a possible Scheme-level “run this relation backward” facility.

Potential Cursors feature

Ask not only:

plan_for(Intent, Plan).

but:

plan_for(?intent, observed_plan_42).

to infer which intents could have produced an observed plan under a bounded model.

Risk

Search-space explosion and ambiguous answers. Keep this separate from the deterministic Datalog substrate and bind it to explicit budgets.

2. Proof-carrying and proof-producing computation

Study proof-carrying data, recursive proofs, proof-carrying authorization, and verifiable computation.

Potential Cursors feature

A remote executor returns:

result root
execution receipt
compact proof of evaluator/profile compliance

Risk

Cryptographic proof does not establish physical side effects, data freshness, honest inputs, or human meaning. It proves only the encoded statement.

3. Category-theoretic open systems

Study open Petri nets, decorated/structured cospans, lenses, and wiring diagrams.

Potential Cursors feature

Define cryptofabric Lego sockets compositionally, with boundaries that can be checked independently and assembled into larger plans.

Risk

Beautiful algebra can outpace executable evidence. Every abstraction must eventually produce a fixture, trace, and cockpit object.

4. Spatial and tangible programming

Study Dynamicland, live objects, augmented physical media, and spatial programming environments.

Potential Cursors feature

A guide or tabletop view where cursor records, grants, horizons, and plans are manipulable physical or spatial objects while their canonical identities remain stable.

Risk

A compelling interface can conceal unsupported semantics more effectively than an ugly one. Evidence labels remain mandatory.

5. Biological and chemical computation metaphors

Study chemical abstract machines, membrane systems, stigmergy, reaction networks, and ecological control interfaces.

Potential Cursors feature

Treat leased assertions as concentrations, interests as receptors, and rules as bounded reactions. This may expose saturation, starvation, and emergent coordination better than RPC diagrams.

Risk

Metaphors are not mechanisms. Adopt only constructs that sharpen formal or operational behavior.

6. Reversible and counterfactual systems

Study reversible debugging, reversible languages, causal-consistent reversibility, and event-structure semantics.

Potential Cursors feature

Fork a horizon, retract one cause, and show the smallest downstream cone invalidated by that intervention.

Risk

External effects are generally not reversible. Compensation is a new effect with new authority and a new receipt.

7. Self-describing, evolvable protocol worlds

Study Smalltalk/Self images, Unison codebases, Preserves schemas, nanopublications, schema evolution, and typed metaprogramming.

Potential Cursors feature

A Cursor World carries source, rule IR, schema, fixtures, inspectors, migrations, and program roots as inspectable objects. Bodies compete to host it.

Risk

Do not make the whole world depend on one immortal image, VM, schema registry, or language implementation.

Research discipline

For every new influence, record:

source
specific mechanism
Cursors invariant affected
smallest executable experiment
required evidence
failure/attack cases
what must remain separate
what would falsify the idea

The correct outcome of research is sometimes deletion. If SQLite, Syndicate, Cap’n Web, a content-addressed store, or an existing coding library already owns a primitive cleanly, Cursors should integrate it rather than manufacture a similarly named subsystem and congratulate itself.