Roadmap

A living document organized by theme, not timeline. Priorities may shift as we learn from community feedback.

Shipped

The core engine plus a full ecosystem – reactive state, AI orchestration, framework adapters, plugins, and developer tools.

Core Engine

• Facts (proxy-based reactive state with auto-tracking)
• Derivations (auto-tracked computed values with composition)
• Constraints (sync and async, with priority and explicit deps)
• Resolvers (async resolution with retry, batching, and cancel)
• Effects (fire-and-forget side effects with auto-tracked deps)
• Events (dispatch and subscribe)
• Module composition (multi-module systems with :: namespacing)
• Error boundaries (configurable recovery strategies)
• Retry policies (exponential backoff, max attempts, timeouts)
• Schema validation (dev-mode runtime type checking, tree-shaken in prod)

Framework Adapters

• React (useDirective, useDirectiveFacts, useDirectiveDerive)
• Vue (composables with reactive integration)
• Svelte (stores and runes support)
• Solid (signals integration)
• Lit (reactive controllers)
• Preact (lightweight adapter)
• Angular (service-based adapter with signals)

AI & Agents

• AI package (@directive-run/ai) with constraint-driven orchestration
• Multi-agent system (planning, delegation, tool use, memory)
• RAG pipelines (retrieval-augmented generation with fact grounding)
• Guardrails (input/output validation, content filtering, budget limits)
• Streaming support (token-level streaming with backpressure)
• Budget and cost tracking (per-request and aggregate limits)
• OpenAI adapter
• Anthropic adapter
• Ollama adapter (local models)

Plugins & Observability

• Plugin architecture (lifecycle hooks, composable)
• Logging plugin (structured, filterable)
• DevTools plugin (state inspection, event log)
• Persistence plugin (localStorage, sessionStorage, custom backends)
• MCP plugin (Model Context Protocol with validation)
• Performance profiler (constraint evaluation timing, resolver metrics)
• Time-travel debugging (snapshots, replay, export/import)
• Changeset-based versioning

Security & Safety

• Prototype pollution guards (all merged objects use Object.create(null))
• Re-entrance guards (flush coalescing, max iteration limits)
• Blocked property checks on dispatch and proxy access
• Error isolation (throwing callbacks cannot bypass recovery)
• Resolver cancel/finally race condition protection
• Namespace collision detection (fact/derivation overlap warnings)

Developer Experience

• Testing utilities (mock resolvers, fake timers, assertion helpers)
• Interactive examples (Sudoku, Checkers, and more)
• Documentation site with guides and API reference
• Migration codemods (Redux, Zustand, XState)
• TypeScript-first API with full type inference

Building

What we're actively working on right now.

• Browser DevTools extension with time-travel UI
• "Why didn't this fire?" debugger for inactive constraints
• Online interactive playground
• More codemods (Recoil, Jotai)

Planned

Scoped and ready to build.

• Actor model support (createActor())
• TypeScript Language Service plugin
• Stale-while-revalidate resolver strategy
• Schema-driven form generation
• SSR hydration patterns cookbook
• Video tutorials

Exploring

Ideas we're excited about. No commitments yet, but these are directions we believe in.

• Visual Constraint Editor
• AI-powered constraint suggestions
• Collaborative debugging
• Codegen CLI
• Community examples gallery

Not planned

Some things are intentionally out of scope. Directive is a runtime for constraint-driven state – not a general-purpose computation engine.

• CRDT / distributed state – Directive manages local application state. Distributed sync is a separate problem best solved by purpose-built tools like Yjs or Automerge.
• Linear / constraint solvers – Our constraints are boolean predicates, not mathematical optimization problems. We won't build a SAT solver.

Have an idea?

We'd love to hear what you'd build with Directive. Share feature requests, use cases, or feedback in GitHub Discussions.