// classic-pages.jsx — site content rendered as DelyxOS windows // Sources: home.jsx, docs.jsx, changelog.jsx, contact.jsx, get.jsx from delyx-site const GITHUB_URL = 'https://github.com/joshua-ivy/Delyx'; const ISSUE_URL = 'https://github.com/joshua-ivy/Delyx/issues/new'; // ────────── Shared bits ────────── function CPChev({ children, color = 'var(--cyan)' }) { return >{children}; } function CPLabel({ children, id }) { return (
{children} {id && ./{id}}
); } function CPCode({ title, children }) { return (
{title && {title}} 
{children}
); } function CPIC({ children }) { return ( {children} ); } function CPCallout({ kind = 'note', children }) { const palette = { note: { c: 'var(--cyan)', label: 'note' }, warn: { c: 'var(--warn)', label: 'heads up' }, bad: { c: 'var(--bad)', label: 'careful' }, }[kind]; return (
> {palette.label} {children}
); } // ────────── HOME ────────── function ClassicHome() { return (
a local-first desktop AI agent

Local LLMs
made easy. Maybe.

Delyx is a desktop agent for people who want local models to feel practical: chat, knowledge, workspaces, evidence-audited research, tool previews, model setup, and a control center in one place. Less weekend wiring. More "wait, that actually helped."

# signed Windows release when available; source path for dev builds{'\n'} $ git clone https://github.com/joshua-ivy/Delyx.git{'\n'} $ cd Delyx{'\n'} $ npm install{'\n'} $ ollama pull phi4-mini{'\n'} $ npm run tauri dev{'\n'} {'\n'} # in Delyx: choose Ollama -> phi4-mini -> Save and test
get delyx -> view source ->
what it does
{[ ['model setup in the app', 'start with one model, then split roles later for answers, helper work, deep research, max reasoning, embeddings, and scoring.'], ['local work with receipts', 'file reads, imports, workspace access, memory saves, edits, commands, connectors, and recurring work use visible approval flows.'], ['control center', 'runs, approvals, connectors, session details, automations, logs, and current status live in one operational surface.'], ['local knowledge store', 'save notes, memories, imported files, and captured web pages; search them with SQLite, embeddings, and hybrid retrieval.'], ['evidence-audited research', 'active retrieval, claim support checks, numeric/date support, coherence checks, reroutes, and conflict rendering.'], ['open, hackable stack', 'Tauri 2, React 19, TypeScript, Rust, SQLite, Ollama APIs, /v1 providers, optional llama.cpp, updater wiring, and MCP over stdio.'], ].map(([t, d], i) => (
0{i + 1}
{t}
{d}
))}
what's actually true
{[ ['ok', 'runs from source with Node.js, Rust, and a model provider'], ['ok', 'Windows is the primary tested platform right now'], ['ok', 'signed Windows installer/updater packaging is configured for public releases'], ['ok', 'Ollama is the lowest-friction first model path'], ['ok', 'OpenAI-compatible /v1 providers are supported, including LM Studio-style servers'], ['ok', 'active retrieval, claim audits, coherence checks, and conflict rendering exist in the source'], ['ok', 'Control Center and responsive shell surfaces are in the app'], ['eh', 'macOS and Linux should be possible through Tauri, but they are less exercised today'], ['eh', 'heavier local stacks need more VRAM, patience, or both'], ['eh', 'beam/tree hypothesis search is still the big reasoning gap'], ['eh', 'advanced systems like reranking, worker agents, reasoning budgets, verifier-led composition, and PRM scoring are experimental or opt-in'], ['no', 'no license file yet, so reuse rules are not finalized'], ].map(([s, t], i) => { const color = s === 'ok' ? 'var(--cyan)' : s === 'eh' ? 'var(--warn)' : 'var(--bad)'; const label = s === 'ok' ? 'ok' : s === 'eh' ? '~ depends' : 'not yet'; const bg = s === 'ok' ? 'rgba(95,212,255,0.10)' : s === 'eh' ? 'rgba(255,200,80,0.10)' : 'rgba(255,120,120,0.10)'; return (
{label} {t}
); })}
unusually honest for a homepage, yes. the product is moving fast, and the source is still the map.
works with
{[ ['ollama', 'recommended start'], ['lm studio', 'OpenAI-compatible'], ['llama.cpp / gguf', 'advanced local path'], ['vllm', '/v1 compatible'], ['openrouter', 'remote provider'], ['hugging face', 'remote provider'], ['searxng', 'optional search'], ['mcp', 'stdio servers'], ].map(([n, s]) => (
>{n}
{s}
))}
why bother
local AI should feel usable

Open-source agent projects can be powerful and still feel like a box of parts. Delyx moves setup, safety checks, context, evidence, and model plumbing into an app where normal humans can actually find them.

beginner path, expert hatch

Simple mode keeps the first run short. Expert mode opens up model roles, evals, diagnostics, reranking, worker agents, release repair checks, and other knobs for the kind of person who hears "knob" and immediately asks how many.

last thing

make local AI practical.

Use the signed Windows release when available, or clone it and run from source. Choose Ollama, pick phi4-mini, and start with one small useful prompt.

get delyx -> read the docs
); } function whyCard() { return { padding: '14px 16px', border: '1px solid var(--line)', borderRadius: 6, background: 'rgba(255,255,255,0.01)', }; } // ────────── DOCS ────────── const DOC_SECTIONS = [ { group: 'start', items: [ ['quickstart', 'quickstart'], ['requirements', 'requirements'], ['first-run', 'first run'], ['release-builds', 'release builds'], ]}, { group: 'app', items: [ ['models', 'models'], ['control-center', 'control center'], ['knowledge', 'knowledge'], ['workspaces', 'workspaces'], ['research', 'research'], ['evals', 'evals'], ]}, { group: 'reference', items: [ ['privacy', 'privacy + data'], ['commands', 'commands'], ['troubleshooting', 'troubleshooting'], ['faq', 'faq'], ]}, ]; function ClassicDocs() { const [active, setActive] = React.useState('quickstart'); const mainRef = React.useRef(null); const jump = (id) => { setActive(id); const el = mainRef.current?.querySelector('#docsec-' + id); if (el && mainRef.current) mainRef.current.scrollTo({ top: el.offsetTop - 16, behavior: 'smooth' }); }; React.useEffect(() => { const main = mainRef.current; if (!main) return; const onScroll = () => { const sections = main.querySelectorAll('[data-docsec]'); let cur = 'quickstart'; sections.forEach((el) => { if (el.getBoundingClientRect().top - main.getBoundingClientRect().top < 80) cur = el.id.replace('docsec-', ''); }); setActive(cur); }; main.addEventListener('scroll', onScroll); return () => main.removeEventListener('scroll', onScroll); }, []); return (
./docs

documentation

The practical path through Delyx: install or run from source, connect a model, keep local actions reviewable, and let evidence earn its chair at the table.

Delyx is source-alpha software with Windows as the primary tested platform. Signed Windows release packaging is configured, but source runs remain the development path between public release builds.

normal Windows install
  1. Open the latest GitHub release when a signed public build is available.
  2. Install Delyx and launch the desktop app.
  3. Choose Ollama, select phi4-mini, then click Save and test.
  4. Start with a small prompt before attaching folders or enabling advanced features.
developer source path # prerequisites: Git, Node.js 20.19+/22.12+, Rust stable, Tauri OS prereqs, Ollama{'\n'} $ git clone https://github.com/joshua-ivy/Delyx.git{'\n'} $ cd Delyx{'\n'} $ npm install{'\n'} $ ollama pull phi4-mini{'\n'} $ npm run tauri dev The first desktop launch compiles the Rust backend. If it takes a few minutes, congratulations: the machine is doing the heavy lifting instead of hiding it.
  • Git for cloning https://github.com/joshua-ivy/Delyx.git.
  • Node.js 20.19+ or Node.js 22.12+.
  • npm, normally installed with Node.js.
  • Rust stable with cargo, because Tauri builds the desktop shell and Rust backend.
  • The platform prerequisites for Tauri 2.
  • One model provider. Recommended first-run: local Ollama with phi4-mini.
Ollama is the easy button, not a prison. Delyx can also use LM Studio, llama.cpp/GGUF, vLLM, OpenRouter, Hugging Face, or any OpenAI-compatible /v1 provider.
  1. Choose Ollama when setup asks for a provider.
  2. Pick phi4-mini, or any Ollama model you already have.
  3. Click Save and test. Delyx stores explicit role assignments for answer and helper work.
  4. Send a small prompt.
  5. Only after that, add stronger models, remote providers, workspaces, or advanced role splits.
 Source builds can report update checks as not configured. That's expected unless DELYX_UPDATER_PUBLIC_KEY and DELYX_UPDATER_ENDPOINT were embedded at build time.

Delyx can start with one model for the whole agent, then split work across runtime roles when you want more control.

runtime role ids $ ollama pull phi4-mini{'\n'} $ ollama pull embeddinggemma{'\n'} $ ollama pull gpt-oss-20b{'\n'} $ ollama pull phi4-reasoning:14b

The desktop app centralizes operational surfaces in Control Center. Be useful without making you chase state across five corners.

{[ ['overview', 'Runtime, approvals, active runs, connectors, sources, failures, recent tools, current status.'], ['approvals', 'Pending, approved, executed, denied actions with payload previews.'], ['automations', 'Now, Upcoming, History, Failed, Paused views with pause/cancel.'], ['responsive shell', 'Mobile drawer, bottom nav, desktop rail collapse, Now status surface.'], ].map(([name, d]) => (
{name}
{d}
))}

Delyx can save notes, memories, imported files, and captured web pages as local knowledge. It can build a searchable local knowledge store using SQLite, embeddings, and hybrid retrieval.

Durable memory is for stable facts and preferences. Temporary test instructions should stay temporary; the eval suite checks for this because accidental memory is where things get awkward.

Attach local folders as workspaces. Delyx can read files, summarize folders, index folders, preview file edits, write files, and run terminal commands through approval flows.

As of May 16, 2026, Delyx has source-backed research, active retrieval, query decomposition, claim audits, global coherence checks, focused post-evidence reroutes, and user-visible conflict rendering.

  • Active retrieval can run up to three evidence-aware rounds.
  • Query decomposition supports general, comparison, diagnostic, causal, temporal, and source-triangulation subtasks.
  • Claim audit checks citation support, evidence IDs, numeric/date support, contradictions.
  • Weak, empty, stale, near-match, missing-field, or conflicting evidence can trigger a focused reroute.
  • The current architecture tracker is docs/REASONING_GAPS_ARCHITECTURE.md.
The big remaining reasoning gap is controlled hypothesis search. ReAct still follows one dominant path unless rescue/reroute logic fires.

The eval harness now covers more than phrase matching. Semantic assertions, numeric tolerances, ranked items, citation support, contradiction expectations, trace markers, opt-in LLM judge rubrics.

$ npm run eval:response{'\n'} $ npm run eval:sports-fixtures{'\n'} $ npm run smoke:responsive{'\n'} $ npm test

Delyx stores app state locally through Tauri's app data directory. Active app id:

com.geaux.delyx

The main local database is <app-data>/workspace/state.sqlite3. Local provider secrets are written outside the repo.

Delyx does not require an inbound gateway daemon for normal use. Optional remote providers, web search, connectors, and update checks can still use network egress when configured. {[ ['The first desktop run is slow', 'Expected: Tauri compiles the Rust backend the first time. Later runs are faster.'], ['Only the web UI opens', 'You probably ran npm run dev. Use npm run tauri dev for the desktop app.'], ['Ollama model is missing', 'Run ollama pull phi4-mini, then refresh model checks.'], ['Ollama is not reachable', 'Start the Ollama app or run ollama serve, then retry setup.'], ['OpenAI-compatible models don\'t appear', 'Start the provider, include /v1 in the base URL, verify /v1/models works.'], ['llama.cpp setup fails', 'Confirm llama-server exists, the .gguf path is real, and it exposes compatible /v1 endpoints.'], ['Update channel not configured', 'Expected in source builds unless updater public key and endpoint metadata were embedded.'], ['No license answer', 'There is no license file yet, so reuse rules aren\'t finalized.'], ].map(([q, a], i) => (
?{q}
{a}
))} {[ ['Is Delyx finished?', 'No. It is active source-alpha software with a real product shape: easy entry first, depth when you ask for it.'], ['What platform is best tested?', 'Windows. Tauri should make macOS and Linux possible, but they\'re less exercised right now.'], ['Can I use a signed installer?', 'Yes when a signed Windows release is published. Source remains the dev path between builds.'], ['Do I have to use Ollama?', 'No, but Ollama plus phi4-mini is the documented first-run path.'], ['Can I use a remote model?', 'Yes. Use an OpenAI-compatible provider path and understand what data leaves the machine.'], ['Does Delyx support MCP?', 'Yes. The app manages MCP servers, with optional MCP over stdio.'], ['Why all the approval friction?', 'Because the app can touch files, commands, memory, and connectors. Useful things deserve visible brakes.'], ['What is the motto?', 'Local LLMs made easy. Maybe. Confidence with a built-in eyebrow raise.'], ].map(([q, a], i) => (
>{q}
{a}
))}
still stuck?
Open an issue with platform, install path, provider, command, and exact error text.
open issue ->
); } function DocSec({ id, title, subtitle, children }) { return (

#{title}

{subtitle &&

{subtitle}

}
{children}
); } function DocH3({ children }) { return (
{children}
); } function DocTable({ rows }) { return ( {rows.map(([c, d], i) => ( ))}
{c} {d}
); } function dsList() { return { color: 'var(--fg-soft)', paddingLeft: 20, lineHeight: 1.75, fontSize: 12, margin: '4px 0' }; } // ────────── STATUS / CHANGELOG ────────── function ClassicStatus() { const fallbackPulse = [ ['source sync', 'origin/main add925a', 'local app fast-forwarded before this page was updated. the source is the map, and the map has fresh ink.'], ['reasoning', 'audits are live', 'active retrieval, claim audit, coherence, reroute, and conflict rendering are in the source tree.'], ['release path', 'windows-first', 'signed Windows installer/updater packaging is configured; source runs remain the dev path between public builds.'], ['mobile shell', 'responsive app pass', 'the app now has responsive nav, bottom navigation, a Now status surface, and a responsive smoke test.'], ]; const fallbackReleases = [ { ver: '0.1.0', tag: 'source alpha · current', date: 'May 16, 2026', note: 'The reasoning pass has landed. Evidence now has a clipboard, a tiny flashlight, and less patience for vibes.', current: true, changes: [ ['new', 'active retrieval is wired into normal execution and can run up to three evidence-aware follow-up rounds.'], ['new', 'query decomposition supports general research, comparison, diagnostic, causal, temporal, and source-triangulation subtasks.'], ['new', 'claim audits check citation support, evidence ids, numeric/date support, and material contradictions.'], ['new', 'weak, empty, stale, near-match, missing-field, or conflicting evidence can trigger one focused post-evidence reroute.'], ['new', 'global coherence checks can surface user-visible Conflicts sections when sources disagree.'], ['new', 'context budgeting now names planning, composition, evidence-heavy, extraction, and chat profiles.'], ['new', 'eval graders cover semantic assertions, numeric tolerances, ranked lists, citation support, contradictions, opt-in LLM judge rubrics.'], ], }, { ver: 'app', tag: 'desktop shell', date: 'Current source', note: 'The app is getting less like a pile of panels and more like a cockpit that knows where the cupholder is.', changes: [ ['new', 'Control Center now gathers runs, approvals, connectors, session details, automations, logs, and recent tool state.'], ['new', 'responsive shell work added a mobile drawer, mobile bottom nav, collapsible desktop rail, Now status surface, and touch-size checks.'], ['new', 'Settings includes repair/update surfaces for signed release builds and privacy controls for masked local provider/search secrets.'], ['new', 'Automations are visible as Now, Upcoming, History, Failed, and Paused views.'], ['tech', 'npm run smoke:responsive runs a Chrome/Edge viewport sweep across overflow, nav, drawer, and status surfaces.'], ], }, { ver: 'release', tag: 'windows packaging', date: 'Current source', note: 'Installer plumbing exists now. Glamorous in exactly the way plumbing usually is: crucial and best when uneventful.', changes: [ ['new', 'Windows release workflow can build signed NSIS/MSI artifacts through GitHub Actions.'], ['new', 'in-app update checks are wired for signed builds when DELYX_UPDATER_PUBLIC_KEY and DELYX_UPDATER_ENDPOINT are embedded.'], ['tech', 'npm run tauri:build:windows prepares updater config and builds Windows installer/updater artifacts.'], ['tech', 'scripts/sign-windows.ps1 handles Authenticode signing when certificate secrets are available.'], ['tech', 'scripts/release-smoke-windows.ps1 verifies installer signatures and app launch behavior.'], ], }, { ver: 'gaps', tag: 'honest bits', date: 'Current architecture tracker', note: 'The website still refuses to cosplay as a finished launch. Very rude. Very useful.', changes: [ ['gap', 'Windows is the primary tested platform; macOS and Linux should be possible through Tauri but are less exercised.'], ['gap', 'source runs are still the development path between public signed release builds.'], ['gap', 'ReAct still follows one dominant trajectory; the next major reasoning upgrade is a small beam/tree controller for hard routes.'], ['gap', 'PRM scoring gates completed steps but does not yet score competing candidate tool plans before execution.'], ['gap', 'worker agents are bounded sidecar helpers, not independent hypothesis-search branches.'], ['gap', 'context budgets have named profiles, but token accounting is still approximate.'], ['gap', 'deeper temporal, arithmetic, unit, recommendation-criteria, and structured conflict checks are still pending.'], ['gap', 'there is no license file yet, so reuse rules are not finalized until a license is added.'], ], }, { ver: 'stack', tag: 'technical notes', date: 'Repo facts', note: 'The tools under the floorboards, now with fewer mystery wires.', changes: [ ['tech', 'frontend: React 19, TypeScript 5.8, Vite 7, Tailwind 4, lucide-react.'], ['tech', 'desktop/backend: Tauri 2, Rust 2021, Tauri command bridge, SQLite with WAL mode.'], ['tech', 'models: Ollama APIs, OpenAI-compatible /v1 APIs, optional llama.cpp GGUF serving.'], ['tech', 'tools: optional MCP over stdio, optional Discord bridge behind a Cargo feature, optional ONNX cross-encoder reranking.'], ['tech', 'app id: com.geaux.delyx; Windows local config path: %LOCALAPPDATA%\\Delyx\\local_config.json.'], ], }, ]; const [siteContent, setSiteContent] = React.useState(() => window.DelyxDefaultSiteContent || null); const [githubStatus, setGithubStatus] = React.useState(null); React.useEffect(() => { let mounted = true; if (window.DelyxCms?.getPublishedSiteContent) { window.DelyxCms.getPublishedSiteContent() .then((content) => { if (mounted && content) setSiteContent(content); }) .catch(() => {}); } if (window.DelyxCms?.getLatestReasoningStatus) { window.DelyxCms.getLatestReasoningStatus() .then((status) => { if (mounted && status) setGithubStatus(status); }) .catch(() => {}); } return () => { mounted = false; }; }, []); const statusHero = window.DelyxCms?.getBlock(siteContent, 'status', 'status-hero'); const statusPulse = window.DelyxCms?.getBlock(siteContent, 'status', 'status-pulse'); const statusReleases = window.DelyxCms?.getBlock(siteContent, 'status', 'status-releases'); const followSource = window.DelyxCms?.getBlock(siteContent, 'status', 'status-follow-source'); const heroTitle = statusHero?.title || 'what is true,\nright now.'; const heroParts = heroTitle.split('\n'); const heroBody = statusHero?.body || 'Delyx is still source-alpha software, but the source moved: reasoning got stricter, Windows release plumbing is in place, and the desktop shell learned some mobile manners.'; const cmsPulse = Array.isArray(statusPulse?.items) ? statusPulse.items.map((item) => [item.title || '', item.body || '', item.detail || item.text || '']).filter((item) => item[0] || item[1] || item[2]) : []; const pulse = cmsPulse.length ? cmsPulse : fallbackPulse; const cmsReleases = Array.isArray(statusReleases?.items) ? statusReleases.items.map(normalizeStatusRelease).filter(Boolean) : []; const githubRelease = normalizeGithubStatusRelease(githubStatus); const releases = [ ...(githubRelease ? [githubRelease] : []), ...(cmsReleases.length ? cmsReleases : fallbackReleases), ]; const tagStyle = (k) => ({ fontSize: 9, fontWeight: 600, padding: '2px 6px', borderRadius: 3, letterSpacing: 1, textTransform: 'uppercase', fontFamily: 'var(--mono)', marginRight: 10, background: ({ new: 'rgba(95,212,255,0.12)', gap: 'rgba(255,200,80,0.10)', tech: 'rgba(95,212,159,0.10)', ok: 'rgba(95,212,159,0.10)', warn: 'rgba(255,200,80,0.10)', bad: 'rgba(255,120,120,0.10)', note: 'rgba(255,255,255,0.06)' })[k] || 'rgba(255,255,255,0.04)', color: ({ new: 'var(--cyan)', gap: 'var(--warn)', tech: 'var(--good)', ok: 'var(--good)', warn: 'var(--warn)', bad: 'var(--bad)', note: 'var(--dim)' })[k] || 'var(--dim)', minWidth: 38, display: 'inline-block', textAlign: 'center', }); const tagLabel = (k) => ({ new: 'now', gap: 'gap', tech: 'tech', ok: 'ok', warn: 'warn', bad: 'bad', note: 'note' })[k] || k; return (
./status

{heroParts[0]}
{heroParts.slice(1).join(' ') || 'right now.'}

{heroBody}

nowavailable in source gapknown gap techimplementation note
{pulse.map(([k, v, detail]) => (
{k}
{v}
{detail}
))}
{releases.map((r, i) => (
> {r.ver === '0.1.0' ? 'v' + r.ver : r.ver}
{r.tag}
{r.date}
{r.current && (
current
)}
{r.note && (

- {r.note}

)}
    {r.changes.map(([k, t], j) => (
  • {tagLabel(k)} {t}
    • ))}
))}
follow the source

{followSource?.body || 'The README, docs folder, and main branch are the live truth until formal releases become routine.'}

{followSource?.cta || 'open github ->'}
); } // ────────── CONTACT ────────── function normalizeStatusRelease(item) { if (!item) return null; return { ver: item.version || item.ver || item.title || 'update', tag: item.tag || '', date: item.date || '', note: item.body || item.note || '', current: item.current === true, changes: Array.isArray(item.changes) ? item.changes.map((change) => [change.tone || change.kind || 'new', change.text || change.body || '']).filter((change) => change[1]) : [], }; } function normalizeGithubStatusRelease(status) { if (!status || !Array.isArray(status.bullets) || status.bullets.length === 0) return null; const generated = status.generatedAt ? new Date(status.generatedAt) : null; const date = generated && !Number.isNaN(generated.getTime()) ? generated.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' }) : 'GitHub source feed'; return { ver: 'github', tag: 'ai source feed', date, note: status.summary || status.headline || 'Generated from the latest README and reasoning docs.', current: false, changes: status.bullets.map((bullet) => [bullet.tone || 'new', bullet.text || String(bullet)]).filter((change) => change[1]), }; } function ClassicContact() { const [form, setForm] = React.useState({ name: '', email: '', subject: 'bug', message: '' }); const [sent, setSent] = React.useState(false); const send = (e) => { e.preventDefault(); const labels = { bug: 'Bug report', feature: 'Feature request', docs: 'Docs / website note', install: 'Install problem', question: 'Question' }; const title = '[' + (labels[form.subject] || 'Delyx') + '] ' + (form.message.split('\n')[0].slice(0, 72) || 'New issue'); const body = [ '## What happened', form.message || '_Describe the issue or request._', '', '## Contact', form.name ? 'Name: ' + form.name : 'Name: _not provided_', form.email ? 'Email: ' + form.email : 'Email: _not provided_', '', '## Context', 'Category: ' + (labels[form.subject] || form.subject), 'Opened from delyx website contact form.', ].join('\n'); const url = ISSUE_URL + '?title=' + encodeURIComponent(title) + '&body=' + encodeURIComponent(body); window.open(url, '_blank', 'noopener,noreferrer'); setSent(true); setTimeout(() => setSent(false), 2500); }; const inp = { background: 'var(--ink-soft)', border: '1px solid var(--line)', borderRadius: 5, padding: '8px 11px', color: 'var(--fg)', fontFamily: 'var(--mono)', fontSize: 12, outline: 'none', width: '100%', boxSizing: 'border-box', }; return (
./contact

say hi.
preferably with logs.

Delyx is open-source and moving quickly. The best contact path is a GitHub issue with your platform, model provider, command, and exact error text. Yes, exact. Vibes are useful; logs are usefuler.

{[ ['project', 'public repo', 'var(--good)', true], ['support', 'github issues', 'var(--cyan)'], ['release', 'windows-first alpha', 'var(--warn)'], ['tone', 'honest, not haunted', 'var(--dim)'], ].map(([label, value, c, dot], i) => (
{label}
{dot && } {value}
))}
how to reach the project {[ { icon: '!', label: 'github issues', value: 'github.com/joshua-ivy/Delyx/issues', note: 'best for reproducible bugs, install trouble, docs fixes, and feature proposals.', href: GITHUB_URL + '/issues', cta: 'open issue ->' }, { icon: '#', label: 'source', value: 'github.com/joshua-ivy/Delyx', note: 'best for README, package scripts, source layout, and current implementation details.', href: GITHUB_URL, cta: 'open repo ->' }, { icon: 'P', label: 'readme', value: 'current source of truth', note: 'best for the latest setup path, docs map, release notes, and current caveats.', href: GITHUB_URL + '#readme', cta: 'read it ->' }, { icon: '!', label: 'private reports', value: 'do not post secrets', note: 'the public repo does not list a private security channel yet. avoid posting tokens, keys, private logs, or sensitive local paths.', disabled: true, cta: 'not public' }, ].map((m, i) => (
{m.icon}
{m.label}
{m.value}
{m.note}
{m.href ? ( {m.cta} ) : ( {m.cta} )}
))}
before you open an issue
  • check the docs and the README first.
  • include your OS, Node version, Rust version, model provider, and command.
  • paste exact error text — not a dramatic reenactment.
  • do not post API keys, tokens, private logs, or sensitive local paths.
issue draft helper
setForm({ ...form, name: e.target.value })} placeholder="optional" style={inp} /> setForm({ ...form, email: e.target.value })} placeholder="optional" style={inp} />
{[ ['bug', 'bug'], ['feature', 'feature'], ['docs', 'docs'], ['install', 'install'], ['question', 'question'], ].map(([id, label]) => ( ))}