Arcane OSSDK docs

Capability first · transport second

Everything an Arcane developer can call.

Start with the job you need to do. Each reference entry identifies its import, result, native/browser/cloud availability, and normalization boundary. Wire protocols and host internals stay folded below the application contract.

On this page

Choose a capability

I need to…UseWhere
Scaffold, test, package, bundle, build, verify, or run an appNode SDK API or arcane CLINode; explicit native provider for native targets
Publish central events, review bounded history, or observe DOM behaviorEventManager and arcane-event-stack/1Node and browser; DOM capture requires a compatible DOM
Build application behavior or UIruntime modules, entities, and componentsBrowser and native WebViews; module-specific dependencies apply
Read platform state or use native OS capabilitiesglobalThis.ArcaneCross-host when the method is implemented and admitted
Use normalized application AIAI.js and globalThis.Arcane.ai; see Arcane.ai.chat()Renderer runtime, native local AI, or explicitly selected cloud provider
Run a caller-authenticated local LLM in the browserarcane-os/ai/browser-wasmBrowser only; secure context, WebAssembly, verified DBOPFS model bytes, WebGPU, and proved full offload; no CPU fallback
Run caller-authenticated Whisper or Kokoro in the browserarcane-os/ai/browser-speechBrowser only; DBOPFS, Web Locks, Workers, and caller-owned immutable runtime/model artifacts
Use provider-specific Ollama fields or admitted operationsOllama provider API (advanced)Native Core; method and application policy may narrow Android access
Observe host, operation, stream, terminal, or appearance eventsArcane.eventsEvent-specific host matrix

Normalized AI first

Ordinary applications start with AI.js or globalThis.Arcane.ai. The renderer module owns chat, streaming, speech, tools, structured output, and the ai-ready lifecycle. The Core namespace provides provider-neutral Arcane.ai.chat() and profile calls behind capability and provider admission.

AIProviderRuntime.js and AIRuntimeState.js normalize independent LLM, STT, and TTS lifecycle and status without selecting a fallback. ConfiguredAIChatSession.js adds bounded conversation history and defaults to Arcane.ai.chat().

For an explicit caller-authenticated browser-local text model, use arcane-os/ai/browser-wasm. It packages the Wllama engine—not model weights or speech—and never executes returned tools. For caller-owned Whisper or Kokoro, use the separate arcane-os/ai/browser-speech provider package; it ships no adapter runtime or model bytes.

Use direct Ollama APIs only when provider-native results or an explicitly admitted provider operation is intentional; renderers never connect directly to port 11434.

Choose the normalized AI surface → · Browser-WASM local AI → · Browser speech →

Complete public surfaces

Package API

200 semantic API records across 14 JavaScript package entrypoints, plus eight versioned schemas and manifest exports. The browser-WASM and browser-speech entrypoints are browser-only; seven update-check records remain explicit and on demand.

Complete SDK API →

Arcane Core

113 callable methods, 35 namespaces, one error constructor, one value, and 14 renderer-visible events. The callables comprise 106 RPC authorities, five renderer-local helpers, and two aliases.

Core reference map → · 37 RPC capabilities →

Every SDK and Core key has one MDN-style focused entry with an overview, operating contract, availability or platform boundary, and safe example. Automated parity tests reject undocumented additions and stale entries.

Every runtime module

Search the entire shipped module directory here, or open the full module index. Each result leads to a first-party page with exact load form, bindings, callable signatures and parameters, lifecycle, literal public events and coded failures, availability, normalization, a copyable contract example, and related Arcane surfaces.

Native, browser, cloud, and cross-host

LabelMeaningNormalization
NodeSDK control plane; not importable by a renderer.SDK errors, CLI events, target descriptors, and receipt lifecycles are versioned.
BrowserUses standard browser APIs; some surfaces also run unchanged in native WebViews.The module or entity owns its local result contract.
NativeRequires an admitted Arcane method or explicit native target provider.Bridge calls and errors are common; platform evidence can remain host-specific.
CloudUses an explicitly configured remote provider over allowed HTTPS.High-level AI helpers normalize selected results; no implicit cloud fallback occurs.
Cross-hostOne application API over WebView2, WebKitGTK, Android WebView, or development HTTP.Exact method contracts are normalized where declared; availability and authority are still checked per host.
Provider-nativeArcane admits and bounds the call but preserves optional provider result fields.Use the documented helper when a smaller normalized result is required.

The current native matrix is Microsoft NT, Linux, and Android where listed. This SDK version exposes no macOS native target or Core-host contract; browser-only behavior on macOS does not become a native Arcane capability.

Read the complete availability and normalization guide →

CLI commands

GroupCommands
Workspacenew, init, doctor
Develop and validatedev, test, check
Browser releasepackage, verify, bundle, verify-bundle
Nativenative-doctor, native-prepare, build, run, targets
Repositoryrepo status, repo pull, repo push

Every command supports --output human|json|ndjson. Machine modes preserve ordered acceptance, progress, terminal result, cancellation, and nonzero failure behavior.

Open the option-by-option CLI reference →

Behavioral and completeness testing

The reference is executable policy, not a hand-maintained symbol list. The suite compares package exports, runtime files and module/entity bindings, Core tables, and focused guides in both directions; it also verifies every component file, its parsed inline scripts, and required catalog metadata. EventManager tests cover pub/sub, immutable history, strict stacks, overflow, playback, cancellation, and DOM privacy. Optional secure:true browser-WASM hardening can add real installed-tarball Chrome proof for strict model hashing, DBOPFS admission, inference, cancellation, unload, and offline reuse; it is not an ordinary publication gate.

node ./bin/arcane-test.mjs test/reference-completeness.test.mjs
node ./bin/arcane-test.mjs test/runtime-api-behavior.test.mjs
npm run check

Read the host and protocol behavior matrix →

Protocol and host details

Application code normally calls one normalized API and lets Arcane choose the admitted host path. Expand these notes only when implementing a host, diagnosing a boundary, or reviewing security and cancellation.

How one Arcane call crosses different hosts

The renderer selects WebView2, WebKitGTK, Android WebView, development HTTP, or standalone transport in that order. Native and development hosts carry the same arcane/1 request identity and Core method semantics where the method exists. A standalone browser exposes no native authority.

Core framing, events, cancellation, and kernel boundaries

Desktop Core uses length-framed JSON RPC over host-private process channels. The development host projects calls through loopback HTTP and events through SSE. Windows and Linux hosts bind different native and kernel evidence beneath the common method policy; Android exposes a deliberately narrower generated projection. Cancellation is cooperative and method-specific, so renderer timeout does not imply rollback of a native mutation.

Central EventManager and time-travel stacks

arcane-os/event-manager is synchronous host-neutral JavaScript. Live listeners receive original arguments; optional history stores bounded, redacted, deeply frozen arcane-event-stack/1 snapshots. That format is local diagnostic data, not Core arcane/1 RPC. Review playback is safe by default; original-event replay is explicit and does not reproduce host or DOM side effects.

Normalized AI versus advanced provider APIs

Applications do not call 127.0.0.1:11434. Start with AI.js or Arcane.ai. Core binds app identity, capabilities, package-owned model policy, native admission, limits, streaming, and errors before using fixed loopback provider routes. Direct Arcane.ollama success envelopes remain provider-native. OpenAI is explicit configuration, never an automatic fallback from local failure.

Open the deep protocol and cross-kernel guide →