You program the deck for real.

The REPL ships on the deck

The bare deck boots into a working KEC Lisp REPL, no cartridge required. Below: three small evaluations, arithmetic, list construction, and a list predicate. It’s the runtime that cartridges load into, running the same code you’d type at the prompt.

Redefine a function while it runs

A function gets redefined while a polling loop is already using it. The loop’s next tick picks up the new binding: no restart, no state lost. This is the part most “programmable” gadgets only claim.

nEmacs: structural editing

nEmacs is the on-deck editor, and it edits s-expressions. The cursor moves over whole forms. Parens auto-balance on insert; deleting a form that would unbalance the tree is refused with an inline message. The kill ring holds whole sub-forms; yank drops the ring entry into a syntactic slot. Select a region and evaluate it against the live runtime without leaving the buffer.

One key, many verbs

TERMis context-sensitive: the same keystroke binds to a different verb depending on where you are. In the REPL it halts evaluation. Inside nEmacs it hands the current form to the REPL. During a cartridge mission it yields the cartridge’s own contextual action.

The runtime, honestly

The whole stack is one library, nOSh (libnosh): a C core plus a Fe system userland, SDL-free, that both the desktop emulator and the device host link against. It passes 120 of 120 tests. The main parts:

KEC Lisp

A real, published, standardized language. It runs on a Fe tree-walking interpreter: arena-allocated, with a mark-sweep GC over a fixed object pool. No unbounded heap growth, no runaway pause; the arena resets at cartridge-load and mission-instance boundaries, so memory pressure is bounded by construction. Fetched at build from the open-source kec-lisp repo.

NoshAPI: 54-primitive FFI

Cartridge Lisp calls into the device through a 54-primitive FFI surface: draw a sprite, put text, spawn a cell, advance a phase. Cart authors never touch C. Source ships as .lsp s-expressions inside a .kn86 container, parsed and walked on load.

DeckRunner

The engine tier: the run loop, the screen router, the cartridge loader, and Mission Control & Mission Runner, the pieces that turn a slotted cartridge into a playable contract. A live World Engine ticks alongside and pushes events into whichever program is active.

Programs that come with the deck

Thirteen first-party programs are chartered for the deck. Some run in the emulator; the rest are on the bench. The REPL, nEmacs, and the Mission Board are furthest along, the ones shown on this page.

• Mission Board· the contract queue
• Deck Hub· operator handle, credits, reputation
• REPL· the live KEC Lisp prompt
• nEmacs· the structural editor
• CONDUIT · net client
• Kinoshita Kommander · files
• AmberCalc · spreadsheet
• Keyring · secrets store
• DOSSIER · records
• RIPSAW, kn9, bzbx, knSALK · tools

Everything above runs in kn86emu on a real desktop. The handheld runs the exact same runtime and cartridge format: the emulator and the device are two hosts over one library.