# 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

- YouTube: https://www.youtube.com/watch?v=NEkO7nUmhzU
- Essay: https://blog.colinbreck.com/predicting-the-future-of-distributed-systems/
- Conference page: https://craft-conf.com/2025/talk/colin-breck

### Watch for

- object storage taking on database responsibilities;
- transactional and analytical systems converging;
- computation moving across an edge/cloud continuum;
- infrastructure absorbing auxiliary application code;
- remaining business logic needing portable, secure execution;
- abstractions leaking, so interfaces must permit migration rather than pretending choices are permanent.

### 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

- YouTube: https://www.youtube.com/watch?v=w8jgUFWVD5s
- Dissertation and materials: https://syndicate-lang.org/tonyg-dissertation/

### Watch for

- the dataspace as shared conversational knowledge;
- assertions, interests, facets, and automatic withdrawal;
- explicit epistemic state;
- coordination that is neither ordinary actor mailboxes nor one global Linda tuple space.

### 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

- YouTube: https://www.youtube.com/watch?v=W8TSPED0alY
- Conference page: https://gotocph.com/2024/sessions/3337/moldable-development-programming-through-custom-tools

### Watch for

- every domain object gaining a purpose-built view;
- tools becoming code and part of ordinary development;
- inspection shaped by the question instead of one universal debugger.

### 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

- Official video: https://www.microsoft.com/en-us/research/video/candidate-talk-debugging-reinvented-asking-and-answering-why-and-why-not-questions-about-program-behavior/
- Paper: https://doi.org/10.1145/1368088.1368130

### Watch for

- asking questions directly about output or absence;
- avoiding developer guesses about low-level code paths;
- distinguishing explanations for what happened from reasons an expected event did not happen.

### 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

- YouTube: https://www.youtube.com/watch?v=QE54x1ahHa4
- Transcript and project page: https://tobyho.com/video/Introducing-the-Deep-Zoom-Debugger.html

### Watch for

- mapping execution time into navigable space;
- semantic zoom through nested execution detail;
- retaining an overview while inspecting one call or state transition.

### 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

- YouTube: https://www.youtube.com/watch?v=PUv66718DII

### Watch for

- immediate connection between creators and the systems they shape;
- visible intermediate state;
- manipulating values while seeing consequences;
- showing several possible futures.

### 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

- YouTube: https://www.youtube.com/watch?v=N2RDQGRBrSY
- Paper: https://arxiv.org/abs/2304.04332
- Repository: https://github.com/egraphs-good/egglog

### Watch for

- combining relational rules with e-graph equalities;
- analyses and extraction over many equivalent expressions;
- incremental computation inside equality saturation.

### 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

- YouTube: https://www.youtube.com/watch?v=6cJMI9z2TeU
- Paper: https://arxiv.org/abs/2004.03082

### Watch for

- e-class analyses;
- rewrite saturation versus greedy local rewriting;
- cost extraction from a space of equivalent programs.

### 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

- YouTube: https://www.youtube.com/watch?v=gCWtkvDQ2ZI
- Conference page: https://thestrangeloop.com/2019/unison-a-new-distributed-programming-language.html

### Watch for

- content-addressed code and definitions;
- one program describing computation across nodes;
- eliminating builds and dependency identity based on names;
- durable distributed computation as a language concern.

### 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

- YouTube: https://www.youtube.com/watch?v=-4Yp3j_jk8Q

### Watch for

- writing state machines before code;
- distinguishing program text from the behavior it permits;
- using mathematics and prose to expose assumptions.

### 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

- YouTube: https://www.youtube.com/watch?v=tfnldxWlOhM
- Talk page: https://codesync.global/media/everything-about-distributed-systems-is-terrible/

### Watch for

- state explosion from small concurrent systems;
- partial failure;
- safety and liveness properties;
- why tests and coding abstractions cannot enumerate possible behavior.

### 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

- YouTube: https://www.youtube.com/watch?v=x7drE24geUw

### Watch for

- metadata cost;
- deletion and garbage collection;
- text/list semantics;
- the gap between convergence and user intent.

### 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

- Official video and transcript: https://gitnation.com/contents/no-rest-for-capn-web
- Source: https://github.com/cloudflare/capnweb

### Watch for

- objects and functions by reference;
- authorization by returning restricted objects;
- promise pipelining;
- symmetric peer RPC and callbacks.

### 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

- Channel/search starting point: https://www.youtube.com/results?search_query=Colin+Breck+streaming+systems
- Essays: https://blog.colinbreck.com/

### Watch for

- streaming systems as living operational models;
- feedback loops and human control;
- edge observations feeding central reasoning without erasing locality.

### 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

- Stanford lecture listing: https://www.dnatube.com/video/24078/Lec-4--A-Structured-Orchestration-Language
- Language site: https://orc.csres.utexas.edu/

### Watch for

- `sequence`, parallel composition, pruning/race, and service orchestration as language operators;
- compositional semantics for distributed workflows.

### 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

- Dedalus: Datalog in Time and Space  
  https://www2.eecs.berkeley.edu/Pubs/TechRpts/2009/EECS-2009-173.html
- A Declarative Semantics for Dedalus  
  https://digicoll.lib.berkeley.edu/record/133539
- Keeping CALM  
  https://doi.org/10.1145/3369736
- Logic and Lattices for Distributed Programming  
  https://www2.eecs.berkeley.edu/Pubs/TechRpts/2012/EECS-2012-167.html
- Datafun: a functional Datalog  
  https://doi.org/10.1145/3022670.2951948
- µKanren: A Minimal Functional Core for Relational Programming  
  https://webyrd.net/scheme-2013/papers/HemannMuKanren2013.pdf

### 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

- Provenance Semirings  
  https://doi.org/10.1145/1265530.1265535
- Whyline / Debugging Reinvented  
  https://doi.org/10.1145/1368088.1368130
- Causeway  
  https://research.google/pubs/causeway-a-message-oriented-distributed-debugger/
- ShiViz  
  https://homes.cs.washington.edu/~mernst/pubs/shivector-shiviz-icse2014-abstract.html
- Oddity  
  https://arxiv.org/abs/1806.05300
- Pivot Tracing  
  https://www.usenix.org/conference/sosp15/technical-sessions/presentation/mace

### 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

- DBSP: Automatic Incremental View Maintenance  
  https://arxiv.org/abs/2203.16684
- Differential Dataflow  
  https://www.microsoft.com/en-us/research/publication/differential-dataflow/
- Better Together / egglog  
  https://arxiv.org/abs/2304.04332

### Experiment

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

- SQLite recursive CTE;
- semi-naive JavaScript;
- Nelua/Wasm join kernel;
- DBSP-style weighted deltas;
- egglog for plan/rule equivalence exploration.

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

- Macaroons  
  https://research.google/pubs/macaroons-cookies-with-contextual-caveats-for-decentralized-authorization-in-the-cloud/
- Biscuit specification  
  https://doc.biscuitsec.org/reference/specifications
- Syndicate macaroon-style capabilities  
  https://syndicate-lang.org/
- Tahoe-LAFS  
  https://papers.agoric.com/papers/tahoe-lafs/abstract/

### 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

- minisketch  
  https://github.com/bitcoin-core/minisketch
- BIP 330 sketch extension  
  https://bips.dev/330/
- Practical Rateless Set Reconciliation  
  https://dl.acm.org/doi/10.1145/3651890.3672216
- Range-Based Set Reconciliation  
  https://arxiv.org/abs/2212.13567
- RaptorQ  
  https://www.rfc-editor.org/rfc/rfc6330.html
- Avalanche network-coded swarming  
  https://www.microsoft.com/en-us/research/project/avalanche-file-swarming-with-network-coding/

### Experiment

Expose three independent gauges:

```text
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

- Emerald  
  https://www.cs.cornell.edu/andru/cs711/2002fa/reading/emerald.pdf
- Obliq, A Language with Distributed Scope  
  https://www.microsoft.com/en-us/research/publication/a-language-with-distributed-scope/
- Ken / MaceKen  
  https://www.usenix.org/conference/atc12/technical-sessions/presentation/yoo
- Beldi  
  https://www.usenix.org/conference/osdi20/presentation/zhang-haoran
- Chorex  
  https://programming-journal.org/2025/10/20/
- Waterken  
  https://waterken.sourceforge.net/

### Experiment

Define the minimum portable continuation as:

```text
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:

```prolog
plan_for(Intent, Plan).
```

but:

```prolog
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:

```text
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:

```text
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.

## Related guides

- [Cursor Logic](cursor-logic.md)
- [Causal Horizons and Why-Not](causal-horizons-and-why-not.md)
- [Cryptofabric Plans and Egglog](cryptofabric-plans-and-egglog.md)
- [Cursors Architecture Lego Board](cursors-architecture-lego.md)
- [Research Questions](research-questions.md)
- [Roadmap](roadmap.md)