Host objects feel native.
Markets, accounts, worlds, sensors and service clients arrive as typed values with stable interface versions.
completion · hover · reference · linking
Kornwolf Research · programming platform
Krank
Typed programs for live systems.
KrankScript brings data, events, state, models and domain objects into one typed language. Krank compiles and runs those programs against declared host capabilities. Kornwolf is the first production host. Axora stretches the same core across creator tools, worlds, visuals and sound.
KrankScript · live proof production
1 plot(close)
● published as an immutable Program revision
↳ rendered live in Kornwolf Terminal
↳ rendered live in Kornwolf Terminal
sourceProgram
→executeKrank
→projectTerminal
01 · KrankScript
One language. Composable worlds around it.
Plain `.ks` uses core KrankScript. `.kfk` and `.afk` select Kornwolf and Axora flavors that compose host capabilities, preludes and operators onto the same grammar, compiler and tooling.
Observables are first-class runtime citizens.
Bars, ticks, trades, books, fills, timers, UI actions, world events and Sensorium signals share one event model.
subscriptions · replay · ordering · budgets
Every powerful action has a type.
Reads, writes, network calls, state changes and privileged actions carry explicit capability and resource semantics.
admission · effects · accounting · policy
02 · Runtime
Compile once. Run inside measured capability boundaries.
Krank owns the semantic IR, linking rules, diagnostics and run contract. Portable execution targets carry programs across servers, tools and future browser or device runtimes.
1Sourcetyped syntax + host imports
→2Semantic IRtypes + effects + host calls
→3Portable artifactcomponent boundary + source map
→4Sandboxfuel + memory + host-call budgets
Replay is part of the language contract.
Clocks, randomness, sparse data, state carry and external evidence become explicit inputs to reproducible runs.
Programs know their operating envelope.
CPU, memory, event rate, host calls, output volume and cancellation produce structured diagnostics and run records.
Hosts publish versioned capability surfaces.
WIT, WebAssembly Components and other maintained standards are under active evaluation for portable host boundaries.
Pine programs get a dedicated migration lane.
Pine compatibility lives behind an adapter and conformance suite while Krank evolves its own event, type and host semantics.
03 · Agents
Describe the idea. Let an agent work with the compiler.
Pulp LLM, Daika, Cortex and Pulp ID already provide routed models, durable agents, owned knowledge and authority. Krank turns compiler and host knowledge into typed tools those agents can use.
Intent becomes a draft Program revision.
The agent receives the active language version, host API glossary, examples and user intent, then edits source through revision-aware tools.
prompt context · examples · host reference
Compiler feedback stays in the loop.
Type errors, source spans, replay fixtures, resource estimates and semantic outputs feed directly into the next agent step.
compile · replay · inspect · explain
Authority stays explicit at the final action.
Publishing pins one exact source revision, host interface set and compiled artifact under the caller's granted authority.
identity · revision · lineage · policy
04 · Toolchain
The compiler powers the whole developer surface.
One source of language truth feeds the CLI, REPL, editor, generated reference, machine-readable API, examples and agent tools.
check · compile · run · test · inspect
Fast local workflows with stable diagnostics, exact compiler versions and reproducible artifacts.
Attach a host and explore it live.
Inspect globals, types, capabilities, events and values, then evaluate fragments inside a declared runtime envelope.
Completion comes from real host types.
LSP data drives completion, hover, signatures, rename, references, semantic tokens and source diagnostics.
Programs become libraries and products.
Versioned imports, examples, templates, forks, lineage, licensing and creator distribution grow from immutable source identity.
05 · Hosts
One core. Different worlds around it.
Each product family publishes a typed host environment and KrankScript flavor. Krank carries compiler behavior, runtime guarantees and tools across them.
Markets
Indicators, signals, market structure, alerts, simulations and bounded strategy logic over canonical market objects.
Worlds
Semantic world behavior, creator systems, workshop logic, Fidget production rules and authored content events.
Perception
Typed visual, audio and experiential outputs driven by live state, events and authored transforms.
Data fabrics
Typed service clients, historical queries and live subscriptions for market, on-chain and domain-specific datasets.
06 · Ecosystem
Krank grows inside a wider toolchain.
Kornwolf Research is the first incubating host. Axora shapes future world and creator hosts. Pulp supplies the agent, model and machine fabric. Freak carries the shared brand system across product surfaces.
Systems, agents and machines
The operating fabric around durable agents, model routing, machines, identity and developer tools.
Cross-surface brand compiler
The shared visual toolchain used to carry product identity across web, native, terminal and agent surfaces.
World and creator hosts
Axora pushes Krank toward richer event, perception, workshop and authored-world host models.
07 · Now
Already running in Kornwolf. Growing into the full platform.
The first production slice compiles and publishes an immutable Indicator revision, executes through Krank and projects into Terminal. KrankScript, the runtime and developer toolchain now expand from that working seam.
Programmable Indicatorlive in production
Immutable Program revisionslive in production
Event + stream modelin design
Typed host APIsin design
Portable sandboxin research + build
CLI · REPL · LSP · agentsin build