Eltes

A local-first AI workspace for real provider APIs, user-run open models, and an honest on-device assistant.

Eltes is a static browser app by default. Hosted requests can go directly from your browser to a provider, or through an optional Vercel/local proxy that forwards your own key for one request and does not persist it. Chats, keys, profiles, and preferences stay in browser storage. There are no simulated hosted-model replies.

Live: https://gefrus112.github.io/eltes/ · Supabase copy: https://odemzfpgercjitrrdlvk.supabase.co/storage/v1/object/public/eltes/index.html — the same files, two hosts.

Developer-agent workflow

Eltes now uses a Claude Code-inspired workflow, not the Claude Code product: inspect → plan → edit → verify → report. It works with your selected supported, tool-capable model, including Claude through the native Anthropic Messages API. Your provider account determines available models and charges; visual presets do not change the model and Eltes does not bundle a frontier coding model.

1. Open app.html, connect a supported provider, and enable Agent mode and Stream responses under Settings. Choose Settings → CTab to customize the interface independently (including Kimi Code- or Claude-inspired styles).
2. Ask for a concrete result, for example: “Build a responsive timer using index.html, styles.css, and app.js. Show a plan, preserve existing work, and tell me what you actually verified.”
3. Watch real source arguments and actions in Code workspace. The model uses native tools, not pretend XML calls. It lists project files, requests reviewed source reads, and prefers exact, small replacements over wholesale rewrites.
4. Approve each source-sharing, write, or execution request in the app. The agent continues useful tool steps without redundant chat questions, but cannot skip approval dialogs. Denied actions must not be retried without your request.
5. Review Plan / Action / Result summaries and actual tool cards. Web preview still needs your click. Local scripts require the separately paired runner. Saved code is not proof that tests passed.

Each turn has at most four provider/tool rounds. On exhaustion, an explicitly labeled Eltes runtime notice reports tool-call counts, points to actual results, and asks for a follow-up instead of claiming the application is finished. This notice is generated by the app, not a simulated model answer. Unavailable tools are blocked; failures are returned to Claude with native is_error metadata.

Execution boundaries — do not confuse working directories with isolation

Environment	Where source runs/lives	Actual boundary
Browser project	Transient per-tab source; HTML/CSS/JS preview in an opaque-origin sandbox="allow-scripts" iframe	No app storage/session access; CSP restricts resources. Frame navigation and renderer stalls are still possible. Not a complete network/resource sandbox.
JavaScript snippet sandbox	Disposable browser worker inside an opaque-origin frame	No DOM or OS terminal; network-restricted; time limited. Optional local TensorFlow.js CPU runtime.
run_project_script	One reviewed saved .py, .js, or .ts file copied to a temporary directory on the local server	Runs with host-account permissions, not OS-sandboxed; temporary source cleanup, timeout and output cap.
run_shell	Local server workspace as initial working directory	Opt-in, paired, loopback/same-origin checked, individually approved; can access resources outside that directory.
Separate Studio UI	Gitignored .studio/ as its initial workspace	Its shell has a separate opt-in switch. .studio/ is organization, not filesystem/network confinement.

Never approve untrusted scripts on a machine containing sensitive data. Hosted GitHub Pages/Vercel/PWA installations do not gain local terminal access. See the execution guide for runtime setup.

Persistent local tools, live terminal cards, and offline 3D

Pair the opt-in local runner to enable the native persistent .studio/ tools:

Tool	Behavior
list_files(directory)	Recursive metadata-only listing, capped at 500 supported files / 1,500 visited entries / 8 path components; skips hidden/protected paths, symlinks and dependency/build directories.
read_file(filePath, startLine?, lineCount?)	Review a source window before sharing with the model. Default 200 lines, max 400; source file max 100 KB.
write_file(filePath, content)	Full before/after approval for a persistent source write; creates missing parent directories only on write.
patch_file(filePath, searchString, replaceString)	Exact unique replacement, reviewed before writing; rejects stale hashes and ambiguous matches.
execute_bash_command(command)	Compatibility name: runs bash on Unix or PowerShell on Windows in .studio/, with individual approval, live logs, 30-second deadline and 32 KB output cap.

These are distinct from write_project_file, read_project_file and replace_project_text, which still target transient browser files. Persistent tools use the paired local server's configured Studio directory (.studio/ by default; the desktop package uses its writable user-data folder). Only the server's ELTES_STUDIO_DIR configuration can redirect it, not a model-supplied path. Hidden/protected paths, traversal and symlinks are refused. File hashes help avoid stale overwrites; they are not transactional protection against another host process racing filesystem operations. This is not an OS container. Shell commands have host-account permissions outside the workspace, including network access. Neither runner is a persistent dev-server supervisor or automatic deployer. The separate Studio terminal also defaults to PowerShell on Windows (its existing ELTES_SHELL override remains). Python and other runtimes must be installed in the same local environment. Chromebook users need an enabled Linux environment and must run and open the local app there; the hosted PWA gains no terminal access.

Every command gets an expandable terminal card in Code workspace. Cards show real pending/running/completed/failed states and streamed stdout/stderr, use native keyboard-accessible disclosure controls, and retain at most 12 runs / 49,152 characters per card in this tab. Output is inert text, never interpreted HTML. A small status marker supplements text; it does not simulate progress. Stop task cancels the active request. Failed checks may lead to a proposed targeted patch and rerun, but each action still requires its approval; there are only four tool rounds.

Three.js preview

Choose Review 3D starter in Code workspace, approve scene.html, then click Preview reviewed code. Or ask a model to write a self-contained scene using THREE and enable Bundled Three.js (offline WebGL2) before previewing. The pinned Three.js r180 bundle is fetched from this app and inlined into the opaque-origin iframe; no CDN, external asset access, allow-same-origin, or unsafe-eval permission is added. https://cloudflare.com is not a library URL.

The starter has a scene/camera, lit torus geometry, resize handling, capped pixel ratio, frame-time-based animation, pause/play controls, hidden-tab suspension, reduced-motion support, resource cleanup and a readable graphics fallback. Obsidian uses black/silver/warm lighting; Graphite uses charcoal/silver/blue. An explicit CTab accent is passed as a validated color. Preferences are sampled at preview start, so restart after changing themes. Frame rate and hardware acceleration depend on the browser/device, not a 60fps guarantee. The usual 30-second preview reset and DOM resource/security limitations still apply. Downloaded starter source needs a local Three.js runtime supplied before its scene script; the library is not embedded into the saved source file. Its MIT license is preserved separately from Eltes's restrictive license. WebGL graphics are optional, not forced onto every generated application.

Screens

_{Vector previews of the interface, drawn from the app's own layout, icon paths and colour tokens by node tools/make-screens.mjs — not screen captures; the conversation and sample data are illustrative.}

Pages

Page	What it is
index.html	Landing page: model catalogue, feature grid and a real sign-up card; links to the video editor
app.html	Chat workspace, streaming, local history, settings, custom endpoints
auth.html	Account page: a real Supabase account (email and password, confirmation, magic link, password reset) when config.js is filled in, otherwise a local profile and provider-key utilities
docs.html	App, local-model, proxy, deployment, privacy, and troubleshooting guide
studio.html	Coding workspace: file tree, editor, live preview, a real local terminal and the Other tools tab (Reel video editor, frame grabber, palette). studio.html?tools=reel opens the editor directly
news.html	Release notes with screenshots of the galaxy backdrop, the effects library, the workflow guide, Studio and the chat theme

Features

• Actual provider requests: native Anthropic Messages API and OpenAI-compatible chat-completions APIs. Responses stream when enabled; errors are shown with retry guidance. Provider availability, model access, quotas, and billing are controlled by each provider.
• Bring your own key: keys are stored in this browser's localStorage. Direct mode sends them from the tab to the selected provider. Optional proxy mode sends a key over HTTPS to the Vercel backend for that request; Eltes's function code does not persist or log the key. Use only a backend you trust. See BYOK and proxy privacy.
• Editor find & replace: Ctrl/⌘+F in Studio opens a find bar over the code, pre-filled from the selection, with a live match count, next/previous (Enter / Shift+Enter) and replace one or replace all. It runs on the textarea's own value, so it works in both local and browser-only modes.
• Local open models: connect Ollama, LM Studio, vLLM, or another OpenAI-compatible server using the Custom endpoint setting. Model weights and inference stay on your own computer/server, subject to that runner's configuration.
• Eltes CAI: a deterministic, on-device JavaScript rules-and-knowledge helper for Eltes guidance, arithmetic, common math functions, one-variable linear/quadratic equations, unit/temperature/time conversion, number-base conversion, date arithmetic, text transforms, random utilities, a curated 50+ term AI glossary, and exact retrieval from messages included in the active chat. It is not a trained neural network or a general-purpose LLM, and it cannot solve every kind of math.
• Local-first workspace: chat history, profiles, settings, and exports are controlled in your browser. No analytics or telemetry are included.
• Chat slash commands: /help, /clear, /export, /model, /calc, /convert, /define, /base, /web, /time, /coin, /dice, /random, /uppercase, /reverse, /sort — handled on-device with a live autocomplete menu; only /web needs a search key.
• Live web search with sources: click the Web chip — it always switches on (and reads Web on) — and Eltes searches Brave, Tavily, Serper or Exa through the optional backend, then renders a numbered source list with links and excerpts. Hosted models are asked to cite sources inline as [1], [2]; CAI formats the same list deterministically. A recency filter (day, week, month, year) is mapped to each provider's own upstream filter. Your search key stays in this browser and is forwarded per request.
• Visible search thinking: while a search runs, the reply shows live steps — the condensed query, provider and recency, the result count and the time each step took. Nothing is pre-scripted; failed searches leave a failed step. Finished traces collapse to a summary and can be reopened; turn them off under Settings → General.
• Eltes Studio: a separate page with a workspace file tree, editor, live preview and a real shell. The Guide button walks the build-a-website workflow — scaffold files, run the build in the terminal, add a page, preview it, open it in its own tab — and ticks steps off as the real actions happen. The written version is in docs.html#workflow. Any .html file previews at /preview/<path> with relative assets intact; edits and terminal builds reload it automatically. The terminal runs /bin/bash in .studio/, streams output, tracks cd, and stops on timeout or Ctrl+C. Without the local server the editor still works in browser-only mode with an in-browser preview and zip export.
• Other tools — Reel, frames and palette: the pinned Video editor tab in Studio opens Reel directly (the Other tools tab holds it next to the frame grabber and palette). It is a video editor that runs entirely in the tab, and studio.html?tools=reel (also ?tool=reel, #reel, #tools=reel) goes straight to it — the landing navigation, hero, features grid, footer and the workspace toolbar all link there. Drop video, image and audio files (or start from the title-card, lyric-video and vertical templates), cut and trim on a snapping timeline, add crossfade, slide, zoom, wipe or flash transitions between clips, give any picture a slow zoom or pan, key position, scale, rotation and opacity with easing, ripple-delete a gap closed, see the music lane's waveform with volume and fades, animate text (fade, rise, drop, pop, blur, typewriter) with five presets, stack looks (cinematic, VHS, noir, dream, neon, golden, mono) and grade each clip, name the project, choose the size, then record the result to a real file. The edit saves as project JSON you can download and open again, and a keyboard sheet in the toolbar lists every shortcut. Export is real-time MediaRecorder capture of the canvas, not a server render: a one-minute edit takes one minute, the tab must stay visible, the file is .webm (.mp4 only where the browser exposes an H.264 encoder), and audio baked into video clips is not captured — use the music lane for the soundtrack. The same tab holds a full-resolution frame grabber and a CSS gradient palette. Projects and media stay in the browser; guide in docs.html#other-tools.
• Effects from code: the Effects button in Studio writes one of six dependency-free recipes — gradient mesh, canvas particles, aurora, halftone, glowing orb, generative poster — into effects/<name>.html, opens it in the editor and loads it in the preview. Every recipe is CSS, SVG or canvas, so there is no bitmap to export or download; the guide is in docs.html#effects. The starter build.mjs walks subfolders, so the effects ship with the site. Release notes with screenshots: news.html.
• MCP servers — Blender and Roblox Studio: a real MCP client (assets/js/mcp.js) with a Settings → MCP tab and an MCP chip in the composer. Presets ship for Blender (via the BlenderMCP add-on) and Roblox Studio (a Luau plugin plus mcp/eltes-roblox-bridge.mjs), each with a downloadable .bat / .sh connector that starts the bridge for you. Connected tools are namespaced server__tool, join the same registry as the built-in ones, and render in the same trace cards. Details: docs.html#mcp.
• Developer-agent loop: brief Plan / Action / Result summaries, native tools, reviewed reads and exact replacements, four-round exhaustion notices, and explicit verification limits. No private reasoning display or approval bypass.
• Agent mode and coding workspace: built-in tools remain available through native hosted-model calls (up to four rounds), while the CAI planner runs supported tools on-device. For coding tasks, the model must show a visible Plan: before requesting a file write or command. File access is limited to a folder you select; reads enter the draft and are sent only when you press Send; each existing-file replacement needs its own full before/after approval. The separate local command runner is disabled by default, requires pairing plus approval for the exact command, and runs with your account permissions—it is not an OS sandbox. Studio also provides a local file editor, preview, and user-operated terminal.
• Reviewed browser code sandbox: JavaScript snippets can be inspected before running in a disposable worker with network access blocked. An optional bundled TensorFlow.js 4.22.0 CPU runtime can be enabled for snippets; you may select compatible local model files, which stay in the tab. TensorFlow.js is a framework, not a chat model, and model weights are not included. Jac (.jac) files have syntax highlighting, attachment, and download support; Jac is not executable in the JavaScript sandbox. See agent and sandbox docs.
• Agent mode, on by default: built-in tools include calculate, convert_units, percentage, date_math, current_time, search_history, define_term and (when enabled) web_search. Hosted models drive them through native function calling (up to four rounds). Eltes CAI-1 has no model to ask, so a deterministic on-device planner runs the same registry itself. It can run six tools; the glossary and web search stay with the hosted loop. Details: docs.html#agent.
• Model catalogue: 66 models across 14 providers, including OpenAI, Anthropic, Google, DeepSeek, Z.ai, xAI, Qwen, Mistral, Groq, NVIDIA NIM, Cohere, OpenRouter, three on-device CAI models, a Lab model you train in the browser, and custom endpoints.
• Real welcome email, from your own machine: creating a profile in auth.html sends Welcome to Eltes AI Workspace through your own free provider account — Resend (3,000/month), Brevo (300/day) or any SMTP mailbox — from lib/mail.cjs, with no dependencies. With nothing configured the message is written to .mail/outbox/*.eml instead of pretending; hard bounces (5xx at RCPT TO, provider 4xx, or a Brevo/Resend webhook) go on a suppression list so the address is never retried. See Welcome email and docs.html#email.
• Desktop apps: a Windows installer and portable .exe, macOS .dmg and Linux AppImage/.deb, built from the same site by desktop/ (Electron shell + the bundled local server), with a hardened window, loopback-only server, recovery screen and CI builds per platform. See Desktop apps.
• Eltes Lab — a model you train: train.html builds a real character-level neural network in the tab: a 14-character context, 24-wide embeddings, 128 tanh units and a softmax over the corpus vocabulary (51,245 weights on the default corpus). Hand-written backpropagation, Adam with bias correction, dropout, weight decay and gradient clipping; training and held-out validation curves drawn live with the best validation point marked. Seeded and reproducible, ~6 ms per step. Memorise it trains on one paragraph until the loss reaches zero and reports the character-level match of the recital. Save model writes the checkpoint to localStorage (eltes.lab.model.v1), and Eltes Lab-1 then answers in the workspace chat by quoting a continuation — with its parameter count, corpus and validation loss stated, because a character model cannot follow instructions. No server, no key, no network requests. Details: docs.html#lab.
• Chat welcome: an orange ember field follows the pointer across the new-chat screen (assets/js/chat-embers.js) — speed is heat, a click stokes it, and it fades out as soon as a conversation starts.
• Interface: Obsidian (true black, no blue) by default with Graphite grey as an option under Settings → General, reduced-motion support, keyboard navigation, streaming indicators, model picker, and local exports. Both themes are tokenised in assets/css/app.css and stored in eltes.settings.v1.

Eltes Lab

assets/js/lab.js is a dependency-free character-level language model: an embedding table for the last 14 characters, one tanh hidden layer of 128 units and a softmax over the vocabulary, with cross-entropy, full backpropagation, Adam (bias-corrected), dropout 0.1, weight decay 2e-5 and global gradient-norm clipping at 5. A 1,500-step run on the built-in Eltes handbook takes about nine seconds in a browser and draws training loss against validation loss on a 90/10 split. assets/js/lab-page.js is the console; tools/capture-lab.mjs re-renders the release-notes figure from a real run (npm install --no-save @napi-rs/canvas).

The model is small on purpose. On corpora of 40–90 KB it overfits: validation loss bottoms out a few hundred steps in and then climbs while training loss falls to nearly zero. The page shows that curve, marks the best validation point and explains it; the memorisation test exists because verbatim recall is the one thing a model this size can prove. Free generation produces word-shaped fragments, and the page says so.

The galaxy backdrop

The marketing and documentation pages sit in front of a live galaxy drawn by assets/js/galaxy.js: a tilted band with a dust lane and a warm core, three parallax star layers, pointer lean, warp trails when you scroll fast, and the occasional meteor. It is one <canvas> with no libraries and no image files; the static backdrop is painted once, stars run at 30 fps with a capped pixel ratio, the loop stops in a hidden tab, and prefers-reduced-motion gets a single still frame. The chat workspace and Studio keep their clean surfaces on purpose. node tools/capture-galaxy.mjs re-captures the still shown in the release notes (requires npm install --no-save @napi-rs/canvas). Details: docs.html#look.

Desktop apps

Watch the 10-minute installation guide on the home page for Windows, macOS and Linux, with English narration, captions, chapter buttons and a full transcript in the docs player. It covers the unsigned v3.18.0 desktop release (verified 2026-10-25), using genuine released-web-interface captures and labeled OS walkthrough illustrations, not recordings of native installers. The video is bundled locally; no external video host or autoplay. MP4 · Authoring and validation.

desktop/ is a thin Electron harness around the same site and the same local server. There is no second app: the shell starts tools/local-server.mjs with its own binary (ELECTRON_RUN_AS_NODE) on a free loopback port and loads app.html from it, so a packaged build needs no Node install and adds no second codebase to maintain.

npm install                    # electron + electron-builder
npm run desktop                # run the harness against this checkout

npm run desktop:win            # Windows: NSIS installer + portable .exe
npm run desktop:mac            # macOS: .dmg + .zip (arm64 and x64)
npm run desktop:linux          # Linux: AppImage + deb
npm run desktop:stage          # just assemble desktop/.build

Platform	Artifact
Windows	Eltes-Setup-<v>-x64.exe (per-user installer) · Eltes-<v>-Portable-x64.exe
macOS	Eltes-<v>-arm64.dmg · Eltes-<v>-x64.dmg · zipped .app
Linux	Eltes-<v>-linux-x86_64.AppImage · eltes_<v>_amd64.deb

The window is hardened (context isolation, no node integration, sandboxed renderer, five bridge calls) and navigation is locked to the app's own origin; everything else opens in your real browser. Permissions are denied except clipboard. The bundled server binds 127.0.0.1 only, and data lives in the platform's app-data folder (studio/, logs/desktop.log, window-state.json inside it). If the server cannot start, a recovery screen shows the error and log path instead of a blank window. Signing is configuration only: set CSC_LINK/CSC_KEY_PASSWORD (Windows) or a Developer ID certificate plus APPLE_ID/APPLE_APP_SPECIFIC_PASSWORD/APPLE_TEAM_ID (macOS).

.github/workflows/desktop.yml builds each platform on its own runner — Windows on windows-latest, macOS on macos-latest (arm64) and macos-15-intel (Intel), Linux on ubuntu-latest — and attaches every installer to the GitHub release when you push a v* tag. Build Windows on Windows: cross-building skips rcedit, so icon and version metadata stay Electron's defaults. Details and troubleshooting: desktop/README.md and docs.html#desktop.

If you only need the website, skip the Electron download:

ELECTRON_SKIP_BINARY_DOWNLOAD=1 npm install

Run the app and local API

Requires Node.js 18 or newer. No build step is needed.

npm install
npm start
# open http://localhost:4173/app.html

npm start serves the site, the local API routes and Studio together, binding to 0.0.0.0 so the development preview can reach it. The built-in proxy is automatically used when Eltes detects the same-origin API. Available routes are /api/health, /api/key-check, /api/chat, /api/search, /api/email/*, and the local-only /api/studio/* endpoints. Studio lives at /studio.html; its workspace is .studio/ (gitignored) and its preview is /preview/. Stop the server with Ctrl+C. The local server has no user authentication and the terminal can run commands as your user; keep it on a trusted network. To bind only to loopback, run HOST=127.0.0.1 npm start. Set ELTES_STUDIO=0 to disable Studio entirely or ELTES_STUDIO_SHELL=0 to keep the editor and preview without a shell.

For a static-only preview, Python also works:

python3 -m http.server 4173

A static-only server does not implement API routes; hosted keys go directly to providers unless you configure a separate proxy in Settings → API keys. The included Windows .bat launcher continues to serve the static site only; configure a Vercel backend in settings if you need proxy/key-test features there.

Connect a local open model

The custom endpoint is compatible with common OpenAI-style chat-completions servers. For example, with Ollama installed:

ollama pull qwen3:8b
ollama serve

In another terminal, run Eltes with npm start, then open Settings → API keys → Custom endpoint and set:

• Base URL: http://localhost:11434/v1
• Model ID: the model name exposed by your runner, such as qwen3:8b
• Key: leave blank if the runner does not require one

The app browser calls the local runner directly. Configure the runner's CORS/origin allowlist to permit the exact Eltes origin (for example, http://localhost:4173). A hosted HTTPS page generally cannot call a plain-HTTP localhost endpoint because browsers block mixed content; run Eltes locally instead. Keep the runner bound to loopback unless you intentionally want other devices to reach it.

Eltes CAI is not a substitute for a large language model. It has no neural checkpoint, training corpus, or training pipeline; its chat retrieval is limited to the active conversation text supplied to the current turn, not every saved chat. A tokenizer vocabulary is not a knowledge base: adding four million word entries would not by itself teach meanings or prevent incorrect answers. Reliable knowledge expansion needs a curated, licensed source corpus, retrieval with traceable sources, abstention when evidence is weak, and an evaluation set. Eltes does not train a frontier or otherwise powerful model from scratch. Running an open-weight model requires downloading its weights and enough RAM/VRAM; fine-tuning requires a separate model-specific dataset, training stack, and compute. The custom endpoint connects to an already-running inference server; it does not perform training.

Optional Vercel proxy

GitHub Pages remains a static host. The separate api/ functions are for Vercel, or can run locally through npm start.

1. Import this repository into a Vercel project with the root directory set to the repository root.
2. Set the Vercel environment variable ELTES_ALLOWED_ORIGINS to a comma-separated list of exact allowed browser origins, with no paths or trailing slashes. Example: https://gefrus112.github.io,http://localhost:4173
3. Deploy the project. Vercel exposes /api/health, /api/key-check, /api/chat, and /api/search.
4. In Eltes Settings → API keys → Optional Vercel/local backend, enter the deployed origin, such as https://your-project.vercel.app, save, and check that the health test succeeds.
5. Use Test key beside a saved provider key, or send a hosted-model message. Clear the backend URL to return to direct browser-to-provider mode.

The proxy supports only provider hosts and provider/model pairs in lib/providers.cjs; it does not accept arbitrary upstream URLs. CORS is not authentication, and an origin allowlist only controls browser cross-origin use. Treat your Vercel project as trusted infrastructure, set provider spending limits, and monitor function usage. No provider key is configured in Vercel: each user supplies their own key with each request. The server code does not persist or log that key, but the key necessarily transits the backend and is visible to the backend platform while the request is processed. Do not use the proxy if you do not trust its operator/platform.

The proxy cannot grant credits, confirm free-tier eligibility, or bypass provider account permissions. Provider pricing and access rules apply to every hosted request. GitHub Pages itself cannot run these functions.

BYOK and proxy privacy

• Browser storage is local to the site origin and is not encrypted by Eltes. Anyone with access to the browser profile may be able to inspect it. Remove keys and clear site storage on shared devices.
• Direct mode sends the key from your browser to the configured provider.
• Proxy mode sends the key in an HTTPS request header to your chosen Vercel/local backend, then forwards it to the fixed provider endpoint. The API code does not write keys to files, databases, or logs. Vercel and the provider still process the request under their own infrastructure and policies.
• Prompts, conversation history, and any enabled tool definitions/results are sent to the selected model service. Avoid sending sensitive content unless you accept that provider's terms.
• Never add provider keys to source code, GitHub Pages, GitHub Actions, screenshots, issue reports, or a shared Vercel environment variable.

Where the site is published

Both homes serve the same static files, unmodified:

Home	Address	What it is
GitHub Pages (canonical)	https://gefrus112.github.io/eltes/	Built by .github/workflows/pages.yml on every push to main.
Supabase Storage (mirror)	https://odemzfpgercjitrrdlvk.supabase.co/storage/v1/object/public/eltes/index.html	A public bucket in the same project that holds the accounts and sends the mail.

The Supabase address is not a "Supabase website" product — Supabase has none. It is a public Storage bucket served over its CDN: every object gets a real content type, relative links resolve, and the pages behave exactly as they do on Pages. It is a mirror, not a second deployment pipeline: it is refreshed on demand from the repository.

# one command, no build step — the Edge Function copies the files from GitHub
ELTES_PUBLISH_TOKEN=… npm run site:publish -- --dry   # list what would go
ELTES_PUBLISH_TOKEN=… npm run site:publish            # upload, upsert, report

supabase/functions/site-publish needs ELTES_PUBLISH_TOKEN set in Edge Function secrets; it refuses every call without it and publishes only pages, assets/ and downloads/ — never the SQL, the tests or the desktop harness.

The Pages workflow itself does not deploy the API functions. GitHub Pages cannot process POST requests, proxy provider calls, hold server secrets, or provide free model credits. For proxy features, deploy the separate Vercel project; otherwise use direct mode or your own local model endpoint.

Windows launcher

downloads/eltes-windows.zip includes the .bat launcher, PowerShell helper, static site, and documentation. Unzip and run eltes.bat; it opens the local workspace and serves only files. It does not start the Node API proxy. To use key testing and the proxy on Windows, configure a Vercel backend in Eltes settings. The launcher requires Windows 10/11 plus Python 3 or Node 18+.

Welcome email

auth.html posts the new profile to POST /api/email/welcome on the server that served the page. That server — yours, not Eltes's — renders a multipart message (plain text plus HTML, no tracking pixel) and hands it to a provider you own. There is no mail server in Eltes, no shared list and no analytics.

# Resend — 3,000 emails/month, 100/day, free
export ELTES_MAIL_FROM="Eltes <[email protected]>"
export RESEND_API_KEY=re_xxxxxxxx

# Brevo — 300/day, free, no domain required
export ELTES_MAIL_FROM="Eltes <[email protected]>"
export BREVO_API_KEY=xkeysib-xxxxxxxx

# or any SMTP mailbox (implicit TLS on 465, STARTTLS on 587)
export ELTES_MAIL_FROM="Eltes <[email protected]>"
export ELTES_SMTP_URL="smtps://you:[email protected]:465"

npm start

Variable	Purpose
ELTES_MAIL_FROM	Sender for the welcome email; required before anything is delivered.
RESEND_API_KEY / BREVO_API_KEY / ELTES_SMTP_URL	Pick one transport.
ELTES_MAIL_PROVIDER	resend, brevo, smtp or none to override detection.
ELTES_MAIL_DIR	Outbox, events.jsonl and suppressed.json. Defaults to .mail/; the desktop app uses mail/ in its data folder.
ELTES_MAIL_WEBHOOK_SECRET	Needed for a webhook reachable beyond loopback.
ELTES_MAIL_REPLY_TO	Optional Reply-To.

Without a provider, /api/email/welcome still does the whole job except the network call: it writes a real .eml file to .mail/outbox/ and answers delivered: false, outbox: true. The auth page shows Saved to the local outbox. On the static GitHub Pages copy there is no local API, so that page uses the Supabase route below instead (or says No mail server on this host when config.js is empty and the hosted function is unreachable).

Bounces are handled where they are observable. SMTP 5xx replies at RCPT TO/DATA are detected in the same request, provider 4xx rejections of the address are treated the same, and POST /api/email/webhook normalises Brevo (hard_bounce, spam) and Resend (email.bounced, email.complained) events. Hard bounces and complaints are written to .mail/suppressed.json; later sends to that address never open a connection.

npm run mail status                       # mode, folder, counts, recent events
npm run mail welcome [email protected]      # send the real welcome email
npm run mail test [email protected]         # verify a provider
npm run mail bounce [email protected]       # record a hard bounce (what a webhook writes)
npm run mail unsuppress [email protected]   # allow the address again

Tests: test/mail.test.cjs covers the wire format, config detection, both provider payloads against a stub, an SMTP delivery over a real socket, a 550 at RCPT TO, suppression, webhook normalisation and the HTTP routes against a spawned server.

Cloud accounts (Supabase, optional)

The static site can create real accounts. Point config.js at a Supabase project and two places grow an email-and-password path: the card on the landing page (index.html#account, name + email + password, straight into the workspace) and the full auth.html page (confirmation, sign in, magic link, password reset, sign out, and a session that survives a reload). The welcome email is then sent by an Edge Function in that same project through Resend — no server of your own, no cost.

// config.js — public identifiers only
window.ELTES_CONFIG = {
  supabaseUrl: 'https://<ref>.supabase.co',
  supabaseAnonKey: 'sb_publishable_…',
  siteUrl: 'https://<user>.github.io/eltes/',
  functionsPath: '/functions/v1',
  mailFunction: 'eltes-mail'
};

npx supabase link --project-ref <ref>
npx supabase db push                                             # tables, trigger, RLS, rate limits
npx supabase functions deploy eltes-mail --no-verify-jwt
npx supabase functions deploy email-webhook --no-verify-jwt
npx supabase secrets set RESEND_API_KEY=re_… ELTES_MAIL_FROM="Eltes <[email protected]>" \
  ELTES_SITE_URL=https://<user>.github.io/eltes/

Set Authentication → URL Configuration to the Pages URL and its wildcard, so confirmation and reset links land on auth.html.

Piece	What it is
assets/js/supabase.js	The browser client: plain fetch, no SDK, no build step.
supabase/migrations/0001_eltes_accounts.sql	profiles, email_events, suppressed_emails, the auth.users trigger, RLS and mail_consume(). It has to be applied before sign-up is useful: without it Supabase Auth creates the user but no profile, so the welcome email has no row to address. npx supabase db push.
supabase/functions/eltes-mail	Welcome, magic link and reset letters through Resend, with the link built by the Auth admin API.
supabase/functions/email-webhook	Svix-signed Resend webhook; bounces and complaints land on the suppression list.
supabase/functions/site-publish	Copies the published site from GitHub into the public eltes Storage bucket.

The service_role and Resend keys live only in Edge Function secrets. config.js ships the publishable key, which is designed to be public; RLS limits it to the signed-in user's own row. Without RESEND_API_KEY the function sends nothing and the panel says Not sent — Supabase has no RESEND_API_KEY yet. See supabase/README.md and docs.html#supabase.

Local profiles are untouched: no config.js, a desktop build, or one click on Use a local profile instead and Eltes behaves exactly as before.

MCP servers (Blender, Roblox Studio, anything else)

Eltes speaks the Model Context Protocol over Streamable HTTP. The client is assets/js/mcp.js; the servers are yours.

Settings → MCP → Blender → Add & connect
  .bat / .sh connector → mcp/eltes-mcp-bridge.mjs → uvx blender-mcp → Blender add-on
Settings → MCP → Roblox Studio → Add & connect
  .bat / .sh connector → mcp/eltes-roblox-bridge.mjs → EltesRobloxBridge.lua in Studio

File	Role
assets/js/mcp.js	Client: initialize → tools/list → tools/call, JSON or event-stream answers, 12 s timeout, per-server on/off
mcp/eltes-mcp-bridge.mjs	stdio → HTTP bridge for command-based servers (Blender)
mcp/eltes-roblox-bridge.mjs	MCP server for Roblox with a command queue
mcp/EltesRobloxBridge.lua	Studio plugin: applies each edit inside an undo recording

Roblox tools: scene_report, create_part, build_model, insert_script, animate_rig, add_effect, scaffold_game, set_properties.

Both bridges bind to 127.0.0.1 only and take an optional --token. Run the tests with node --test test/mcp.test.cjs — they spawn both bridges and simulate the Studio plugin, so no Blender or Roblox install is needed.

Eltes CAI engine (Rust)

engine/ is a zero-dependency Rust crate that reimplements the deterministic part of Eltes CAI — the tokenizer, expression parser, unit and temperature conversion, date maths and the answer router — behind a cai CLI:

cd engine
cargo test                 # unit tests + parity against the shared vectors
cargo run --quiet -- "12 km to miles"   # -> 7.4564543068 miles
cargo run --quiet -- --expr "2 + 3 * 4" # -> 14

engine/tests/parity.rs reads the same ports/vectors.tsv the other implementations use, so the crate cannot drift from the ports. Details: engine/README.md.

Language ports

ports/ holds one small, dependency-free implementation of the CAI contract per language, all checked against a single conformance file, ports/vectors.tsv — 49 cases covering arithmetic, implicit multiplication, factorials, unit and temperature conversion, percentages, date maths and the refusal paths.

Language	File	Run
Python	ports/python/cai.py	python3 cai.py ../vectors.tsv
JavaScript	ports/javascript/cai.js	node cai.js ../vectors.tsv
TypeScript	ports/typescript/cai.ts	npx -p typescript tsc && node dist/cai.js ../vectors.tsv
Perl	ports/perl/cai.pl	perl cai.pl ../vectors.tsv
C	ports/c/cai.c	cc -std=c99 -Wall -Wextra -Werror -O2 cai.c -lm -o cai && ./cai ../vectors.tsv
C++	ports/cpp/cai.cpp	c++ -std=c++17 -Wall -Wextra -Werror -O2 cai.cpp -o cai && ./cai ../vectors.tsv
Go	ports/go/main.go	go run main.go ../vectors.tsv
Ruby	ports/ruby/cai.rb	ruby cai.rb ../vectors.tsv
PHP	ports/php/cai.php	php cai.php ../vectors.tsv
Java	ports/java/Cai.java	javac Cai.java && java Cai ../vectors.tsv
Kotlin	ports/kotlin/Cai.kt	kotlinc Cai.kt -include-runtime -d cai.jar && java -jar cai.jar ../vectors.tsv
C#	ports/csharp/Cai.cs	dotnet run -- ../vectors.tsv
Lua	ports/lua/cai.lua	lua cai.lua ../vectors.tsv
AWK	ports/awk/cai.awk	awk -f cai.awk ../vectors.tsv
Julia	ports/julia/cai.jl	julia cai.jl ../vectors.tsv
R	ports/r/cai.R	Rscript cai.R ../vectors.tsv
Dart	ports/dart/cai.dart	dart cai.dart ../vectors.tsv

Every row runs in CI (.github/workflows/ports.yml, one job per language). Adding a language means adding a file, a matrix row, and — if it finds a new edge — a vector. Details and the contract: ports/README.md.

Validate and rebuild

npm install
npm run validate:html
npm run validate:css
npm test
npm run downloads:build

The Windows ZIP is generated from the current source/docs and includes the current LICENSE and third-party NOTICE.md.

Storage

Browser key	Contents
eltes.chats.v1	Conversations
eltes.settings.v1	Model, provider keys, proxy URL, preferences
eltes.active.v1	Open conversation
eltes.account.v1	Optional local profile
eltes.cloud.v1	Supabase session (access + refresh token), when cloud accounts are configured

Storage is per browser and origin. Export chats before clearing site data.

License and reuse

This release is distributed under the restrictive terms in LICENSE, not MIT. Two directories are the exception and carry their own MIT licences: engine/ (the Rust crate) and ports/ (the language ports). The source is publicly viewable because the repository is public; that does not grant permission to copy, redistribute, modify, or publish a clone. The license cannot technically prevent downloading or forking public files. The prior MIT-licensed versions remain subject to the rights granted with those releases; this change is not retroactive. Third-party assets retain their own licenses in NOTICE.md. This is a project notice, not legal advice.

CTab — customize chat design

Open Settings → CTab to choose Eltes, Claude-inspired, Gemini-inspired, ChatGPT-inspired, Kimi Code-inspired, or Notebook layouts. These are visual adaptations within Eltes, not official product clones or new provider integrations. Your selected model, provider keys, and conversation contents do not change.

Customize the dark surface theme (Obsidian or Graphite), accent color, answer font, message layout, chat width, text size, corner radius, and message spacing. Changes apply immediately to all chats on this device and are stored in local settings. The labeled sample preview is only a visual specimen, not a model response. Reset chat design restores the default black layout without clearing chats or keys. Fonts are local system fonts; arbitrary CSS, scripts, and external resources are not accepted. Reduced-motion preferences remain respected.

Browser coding and local ML

Ask a connected, tool-capable hosted model to build a website with write_project_file. Approve each source file, then edit it in Code workspace and click Preview reviewed code. Files are virtual, transient, top-level source files (24 files, 100 KB per file); download them before closing the tab. Preview supports local plain HTML script/stylesheet references, not ES modules, npm or filesystem access. CSP blocks resource fetches, but DOM previews are not a network-security boundary: scripts can navigate the frame or freeze a renderer. Never put private data in preview code.

More reliable project editing

The coding tools can now list_project_files, request a reviewed read_project_file, and make a precise replace_project_text edit. Reading a saved virtual file shows its complete contents and requires consent to send that source back to the selected provider. It never reads the device filesystem or an unsaved editor draft. Replacements must match exactly once, preserve unrelated source, and show the full proposed file for approval. Missing/ambiguous matches, unsaved edits, and changes during review are refused rather than silently overwritten. This improves the editing workflow, not the underlying model's trained abilities.

The editor reports lines, byte size and unsaved state; Tab inserts two spaces, Ctrl/Cmd+S saves in the tab, Escape then Tab moves to the next control, and Shift+Tab moves keyboard focus backward. Indentation resumes after refocusing. Save or explicitly Discard edits before switching files. A model saving another file won't discard your active draft. Execution remains separately approved, and models are instructed to report actual checks rather than invent test results.

Watch code being written and run scripts

With Agent mode and streaming enabled, the Code workspace opens as real write_project_file arguments arrive from your selected tool-capable provider, including Claude through the Anthropic Messages API and OpenAI-compatible models. The live draft is read-only and is not saved or executable until you approve the complete file. Streaming off shows the completed draft instead. This does not use simulated model responses; bring a valid provider key and a model your account can access. Hosted calls may incur provider charges. CAI is not a general coding LLM.

The activity panel shows file reviews, completed writes, live stdout/stderr, exit codes and failures. It stays non-modal so chat remains accessible; Stop task cancels generation and any active local execution. Closing the panel only hides it and stops the website preview; it does not cancel the task. Reopen it with Code workspace. The bounded activity/draft display is transient, not a persistent terminal.

For real script execution:

1. Install Node.js locally; 22.18+ (24 LTS recommended) is required for native TypeScript. Install Python separately for .py files.
2. Start the local app with ELTES_ENABLE_SHELL=1 npm start (macOS/Linux), or eltes.bat --shell in the Windows download. Open the local app in the same machine's browser, then pair the token printed by the server using Local runner.
3. Ask, for example: “Show a Plan, create hello.py with write_project_file, then run it with run_project_script and check the output.” Approve the source save, then separately approve the exact saved source for execution. You can also edit, Save in tab, and click Run saved script locally yourself.

run_project_script accepts a saved .py, .js or .ts filename. Only that file (up to 100 KB) is copied to a fresh temporary directory, executed with Python or Node.js, and cleaned up after exit. Sibling files and dependencies are not copied; no packages are installed automatically. TypeScript supports Node's erasable type syntax, not JSX, tsconfig transforms, or a bundled TypeScript compiler. Python uses python3 on Unix and python on Windows; set ELTES_PYTHON on the local server to an alternate interpreter executable if needed. Scripts have a 30-second deadline and a 32 KB combined stdout/stderr cap. Output from a model-requested run is sent back to that provider so it can explain or fix failures; fixes and reruns need fresh approval. run_shell still supports separately approved commands in the local server workspace, including commands for existing scripts.

Local scripts and shell commands are not OS-sandboxed: they run with the server account's permissions and may access the filesystem/network. Limited text filters are not a security boundary. Use only trusted code in an environment you control. Loopback, same-origin and token checks still apply; a hosted PWA, Vercel deployment, GitHub Pages, or a forwarded preview does not gain local terminal access. The hosted UI can still write/edit files and preview websites. For JavaScript without a local runner, use Review JS in browser sandbox, which opens the existing review-first, network-blocked worker instead (no DOM, imports, or OS access).

JavaScript fence Run opens the reviewed worker sandbox. TensorFlow.js is optional and unchecked by default. Enable it to use tf, loadLocalLayersModel() or loadLocalGraphModel() with a compatible model.json plus weight shards selected locally. No model weights or general-purpose neural chat model are bundled. TensorFlow.js runs on CPU with a 30-second limit; ordinary snippets have an eight-second limit. Model files stay local and are cleared when the dialog closes. The third-party runtime retains Apache-2.0 terms.

Studio’s user-operated OS shell now requires ELTES_STUDIO_SHELL=1; the chat command runner separately requires ELTES_ENABLE_SHELL=1, pairing and exact-command approval. Neither is an OS sandbox. Jac is supported as source text, not browser execution.

The latest main’s static Supabase login remains at auth.html. The branch’s HttpOnly-cookie account flow is retained separately at cookie-auth.html (requires /api/auth on local/Vercel). They have independent sessions and profile tables; chat currently displays the static profile.