WinterCave 0.3.1
Source

Rust 0.3.1 · local · no npm

A text editor you run,
not a service you join.

WinterCave is one Rust program. It serves the editor page, tokenizes the file with its own engine, suggests the word you are half-way through typing from the file itself, and writes the result atomically — inside a folder you choose, on a port you choose, with no account anywhere.

Engine
wintercave-core
Shell
wintercave-server
Build step
none
Listen
localhost

What it is

Two crates, one process

The engine knows nothing about the web; the server knows nothing about tokenizing. That split is the whole architecture, and it is why the same editor could later drive a native window without rewriting the rules.

crates/wintercave-core

The engine

An immutable document model, applied edits, undo history, search, multi-cursor selection, smart editing (pairs, indentation, comments), the keymap, the subsequence matcher, and the tokenizer for twelve languages. No DOM, no filesystem, no async runtime.

  • Byte offsets, boundary-checked — never a split emoji
  • One #[test] set per rule, and they are the specification
  • Also compiled to WebAssembly, kept working, loaded by nothing

crates/wintercave-server

The shell

One actix-web program. It renders the page as HTML, embeds the stylesheet and the one small script, and owns every byte of I/O: reads, writes, atomic replace, and a file API confined to --root.

  • Atomic writes: temp file beside the target, fsync, rename
  • .., absolute paths and NUL bytes rejected before disk
  • Works with JavaScript off — a plain form posts the buffer

The whole API

  • GET /the editor, server-rendered
  • GET /?dir=a folder: breadcrumb, folders, files
  • GET /?path=a file, opened
  • POST /save?path=the no-JavaScript form save
  • POST /api/highlighttext in, tokens out
  • POST /api/completecaret in, suggestions out
  • POST /api/findquick open, ranked
  • GET /api/files /api/tree /api/healthread, list, report

On screen

The page, without the marketing

This is the editor as the server renders it: a folder legend on the left, the terrain on the right, the caret's position in the bottom left. Pick a feature below and the matching region is marked.

Features

Five things, honestly described

Run it

Two commands, a localhost tab

You need Rust. You do not need Node, npm, Docker, or an API key.

bash
$ cargo run -p wintercave-server -- --port 4173 --root .
  wintercave-server 0.3.1
  root: /home/you/project
  listening on http://127.0.0.1:4173

Open http://localhost:4173. The left column is the workspace, the right one is the editor. ⌘S saves; ⌘P opens a file; the theme button is in the header.

  • --root <dir> the only folder it may touch
  • --read-only open files, refuse every write
  • --host 0.0.0.0 deliberately expose on your network

It binds to 127.0.0.1 by default. There is no auth or TLS; use --host 0.0.0.0 only when you deliberately want trusted devices on your network to reach the editor.

Limits

What it deliberately does not do

A tool is easier to trust when it says where the edges are. These are the real ones, at 0.3.1.

Known limitations of WinterCave 0.3.1
LimitWhy, and what to do
No auth, no TLS A local tool, not a hosted one. Bind 127.0.0.1 or keep it behind your own proxy.
One file at a time No tab strip; opening a file is a page load. The folder browser walks one level at a time.
Highlighting is a round trip Typing is instant — it is a textarea. Colours arrive ~120 ms later, and stop working above 400 KB.
Completion is local Keywords, constants and words already in the file. No language server, no type inference, no model.
Quick open is bounded Six levels and four thousand entries per search. It is a convenience, not an indexer.
Multi-cursor and find/replace Implemented and tested in the engine, not yet wired to this page. The engine is the spec.