Veyra Studio 0.3 combines Monaco editing, project navigation, Git tooling, a real terminal, installable themes/snippets and a multi-provider AI assistant with reviewed edits.
Preview · Features · AI Vision · Quick Start · Architecture · Roadmap
Veyra desktop interface — project Explorer, editor workspace, command search and native terminal.
Most developers spend hours every day inside an editor. Veyra is being designed around the idea that this environment should be fast, local, visually calm and intelligent by default.
The project starts with a strong desktop foundation first: real local files, native project access, a proper shell, Monaco editing and predictable developer workflows. The next layer is AI — not as a separate chatbot bolted onto the side, but as tooling that can eventually understand the workspace, propose changes, explain code, help debug and operate across files with the developer in control.
Current status: Veyra Studio 0.3 ships AI chat, local/cloud model selection, file/selection attachments, and reviewed edits with undo. It also includes dimensional file/folder icons and Open VSX theme/snippet installation. Autonomous agents, project-wide semantic indexing, automatic inline AI completion and general VS Code extension hosting remain future work. See the Studio setup and usage guide.
| Area | Current capability |
|---|---|
| Editor | Monaco-powered editing with syntax highlighting, find/replace, formatting support and JavaScript/TypeScript diagnostics |
| Explorer | Open local folders, browse nested directories, expand/collapse trees and refresh the workspace |
| File creation | Create files and folders inside the selected directory, including nested paths such as components/ui/Button.tsx |
| Tabs | Work across multiple files while retaining unsaved buffers |
| Navigation | Quick Open, command palette, workspace search and detected-symbol outline |
| Terminal | Real interactive shell rendered with xterm.js and backed by a native Rust PTY |
| Git | Repository branch/status inspection and tracked-file diffs against HEAD |
| Safe writes | Atomic saves plus protection against silently overwriting externally changed files |
| Desktop runtime | Native Tauri application with Rust filesystem, search, Git and PTY commands |
| Customization | Dark/light themes, font controls, minimap, word wrap, resizable UI and split view |
| Extensions | Search Open VSX, install compatible themes/snippets or import VSIX, apply themes, disable and uninstall |
| AI Studio | Ollama, OpenAI, OpenRouter and compatible text-chat APIs; attach a file/selection, review a diff, apply to the buffer and undo |
| Visuals | Dimensional SVG file/folder icons, refined surfaces and a responsive right-hand AI panel |
Veyra operates on your actual local project. The integrated terminal runs with your normal user permissions, so only execute code and commands you trust.
The long-term goal is for Veyra to become an AI-native code editor where intelligence is part of the coding workflow rather than a disconnected chat window.
Chat, model switching, explicit file/selection context and single-file diff review ship in 0.3. The broader capabilities below describe the longer-term direction. Cloud providers require your own API keys; keys stay in native process memory for the current session. Ollama must be installed and have a downloaded model. Connection instructions →
| Capability | Direction |
|---|---|
| Codebase-aware chat | Ask questions with workspace files, symbols and project structure as context |
| Inline AI editing | Select code, describe a change and review the generated diff before applying it |
| Multi-file changes | Let AI propose coordinated edits across several files with explicit approval |
| Explain & refactor | Explain unfamiliar code, simplify functions and suggest safer abstractions |
| Debug assistant | Use diagnostics, terminal output and relevant files to reason about failures |
| Test generation | Generate focused unit/integration tests from the code being edited |
| AI command palette | Invoke transformations and common engineering tasks from the keyboard |
| Terminal intelligence | Suggest commands and interpret errors without silently executing destructive actions |
| Model flexibility | Architecture for cloud or local model providers instead of tying Veyra to one vendor |
| Developer control | Clear context boundaries, visible diffs and explicit confirmation for file-changing actions |
The target experience is closer to:
Developer intent
↓
Workspace context
↓
AI reasoning / proposal
↓
Visible diff or suggested action
↓
Developer approval
↓
Native Veyra file / terminal tooling
AI should accelerate the developer — not take control away from them.
For the currently tested macOS workflow:
- Node.js 22.12+
- npm
- stable Rust + Cargo
- Git
- Xcode Command Line Tools
xcode-select --installgit clone https://github.com/fcopensource/veyraeditor.git
cd veyraeditor
npm ci
npm run tauri devThe first Rust build may take a few minutes.
npm run devstarts only the Vite frontend. Usenpm run tauri devfor the complete desktop editor with native filesystem and terminal functionality.
On macOS:
npm run tauri build -- --bundles appThe application bundle is generated under:
src-tauri/target/release/bundle/macos/
For a public release, macOS signing/notarization and proper Windows/Linux packaging still need to be completed.
flowchart LR
UI[React + TypeScript UI] --> Monaco[Monaco Editor]
UI --> Explorer[Workspace Explorer]
UI --> Terminal[xterm.js Terminal]
UI --> IPC[Tauri IPC]
IPC --> Rust[Rust Native Backend]
Rust --> FS[Filesystem]
Rust --> Search[Workspace Search]
Rust --> Git[Git Inspection]
Rust --> PTY[Native PTY / Shell]
UI --> AI[AI Studio]
AI --> Context[Explicit file or selection context]
Context --> IPC
Rust --> Models[Ollama / OpenAI / OpenRouter / Compatible APIs]
AI --> Review[Diff review and undoable buffer edits]
Tauri 2
Rust
React 19
TypeScript
Monaco Editor
xterm.js
portable-pty
Vite 7
Playwright
veyraeditor/
├── src/
│ ├── App.tsx
│ ├── App.css
│ ├── CreateEntryDialog.tsx
│ ├── Terminal.tsx
│ ├── editor.ts
│ └── main.tsx
│
├── src-tauri/
│ ├── src/
│ ├── capabilities/
│ ├── icons/
│ └── tauri.conf.json
│
├── public/
│ ├── veyra.png
│ └── screenshots/
│ └── veyra-ai-editor-preview.jpg
│
├── tests/
├── package.json
└── vite.config.ts
| Shortcut | Action |
|---|---|
Cmd+O |
Open workspace |
Cmd+N |
New file |
Cmd+S |
Save active file |
Shift+Cmd+S |
Save all |
Cmd+W |
Close active tab |
Cmd+P |
Quick Open |
Shift+Cmd+P |
Command palette |
Cmd+F |
Find |
Option+Cmd+F |
Replace |
Shift+Cmd+F |
Search workspace |
Shift+Option+F |
Format document when supported |
Cmd+B |
Toggle sidebar |
Cmd+L |
Toggle AI assistant |
Cmd+K |
Edit selected code with AI |
Cmd+Enter |
Send the AI prompt |
Cmd+, |
Preferences |
These shortcuts currently reflect the macOS build.
# Frontend type-check + production build
npm run build
# UI regression tests
npx playwright install chromium
npx playwright test
# Native Rust tests
cd src-tauri
cargo test --libPlaywright tests exercise the UI with mocked native IPC. Rust tests cover native behavior such as workspace path validation, symlink escape protection and save-conflict handling.
Veyra is designed around local project ownership.
Editor-side native file operations are scoped to the selected workspace. Files are written defensively, and Veyra checks for save conflicts when another process changes a file on disk.
AI sends only the displayed conversation and explicitly attached file/selection to the chosen provider. Local Ollama mode excludes cloud aliases. Cloud requests may incur provider fees. Reviewed changes update the editor buffer, require an explicit save, and are rejected if the original file or workspace changed. AI does not execute shell commands or automatically write files.
- Monaco editor
- Local workspace Explorer
- Nested file/folder creation
- Multi-tab editing
- Workspace search
- Command palette
- Real integrated terminal
- Git status/diff inspection
- AI Studio panel
- Workspace-aware context engine
- Selected-code AI edit + diff review
- Automatic inline AI completion
- Multi-file AI plans
- Explain / refactor / debug actions
- Test-generation workflow
- Terminal-aware assistant
- Provider abstraction for cloud/local models
- Language Server Protocol integration
- Rich Python/Rust diagnostics and completion
- Debugger + breakpoints
- Git staging / commit UI
- Independent split-editor panes
- Session restore and crash recovery
- Theme/snippet extensions from Open VSX and VSIX
- General VS Code extension runtime
- Signed macOS releases
- Verified Windows builds
- Verified Linux builds
- Automatic updates
- Download page at veyraeditor.com
Veyra is open source and contributions are welcome.
Fork the repository, create a focused branch, make your changes, run the relevant tests and open a pull request with a clear explanation. For UI changes, screenshots are strongly encouraged. For native filesystem behavior, regression coverage is especially valuable.
Please do not commit credentials, private workspace data, dependency directories or generated release artifacts.
Veyra Editor is released under the MIT License.
Copyright © 2026 Vikram Singh.
Your code. Your machine. Your AI.
Built for developers who want a focused editor today — and a genuinely AI-native development environment tomorrow.
If the project interests you, consider giving the repository a ⭐