butter 黄油 — huáng yóu

a session management viewer

butter is a session management viewer: control many avatars at the same time, from one program, without the resource cost of running several viewers at once — and without the data and cache corruption that running several viewers on one machine causes. one client.* surface, bound per session, drives the window you sit in and every headless bot alike — no globals, no gCurrentAgent. rust is the host, luau is the payload.

what it is

one client, many sessions. the window you sit in plus other logged-in avatars, all in the one place, sharing region state instead of each running its own viewer with its own cache on the same disk. a single script can move the whole group at once. an instance can also run headless — no window, just scripts on their own schedule.

what it does

control many avatars at once, switch between them, script all of them
one running process, one cache — no per-viewer data or cache corruption
run headless, no window
hold the circuit — a faithful xml-rpc login and udp transport, gate-measured against a real sim
render the world — one renderer, many views, possess between sessions
instance alts and bots from a script, each with its own client.* and its own capabilities
read and send instant messages, talk to the region, keep state in storage

the plan

butter works, and the whole of where it is going is drawn out. the client was built gate by gate — proto, session, region, detail, luau, view — each measured before the next opened. from that, the plan was written down and is being walked:

a scriptable ui suite — the chrome grows into windows, panels, buttons, text fields, sliders, lists. luau owns what the ui is, rust owns how it looks. the default second life interface comes back as a drop-in, re-described in luau instead of loaded from xml.
a browser that is actually usable — parcel media, media on a prim, and safe links, on the cheap. servo embedded as a library, rendered offscreen, its network gated by the same capabilities the session already carries.
a faithful renderer — prims, meshes, and sculpties resolved into a scene graph and drawn by wgpu, batched by mesh and material instead of per-prim draw calls. terrain, water, sky, and avatars each get their own system. the whole thing aimed at beating the legacy viewer's single-core lock and everything-resident memory.
a login that mirrors ll's — the wire protocol and password hashing are already faithful; the screen and the sub-account roster are designed. a primary login owns the process, and the alts and bots live one floater away.
parcel music — the parcel's stream, autoplay and autoswitch like the viewer, with icecast metadata reachable from a script.

butter is a separate repo — it shares no code with the alchemy fork, which stays as the working reference. rust is the host, luau is the payload, and a session is always a value, never a global.

built by one person

no team here — just me, wood. one operator, one client, and a special thanks to the programming models i use to get the work done: claude sonnet and opus, gemini pro and flash, and deepseek v4 flash — the 2025-2026 generation. the pair programmer in my ear is as much a part of the build as the keyboard.