https://github.com/webspoilt/zynta-studio
🚀 A groundbreaking, multi-agent powered Intelligent Development Environment blending generative UI, decentralized orchestration (SEMAP), and a Transactional VFS. It codes alongside you.
https://github.com/webspoilt/zynta-studio
agent ai devtools generative-ai generative-ui ide mcp multi-agent react rust tauri
Last synced: 4 months ago
JSON representation
🚀 A groundbreaking, multi-agent powered Intelligent Development Environment blending generative UI, decentralized orchestration (SEMAP), and a Transactional VFS. It codes alongside you.
- Host: GitHub
- URL: https://github.com/webspoilt/zynta-studio
- Owner: webspoilt
- License: gpl-3.0
- Created: 2026-02-23T11:23:51.000Z (4 months ago)
- Default Branch: master
- Last Pushed: 2026-02-27T09:05:17.000Z (4 months ago)
- Last Synced: 2026-02-28T16:38:10.535Z (4 months ago)
- Topics: agent, ai, devtools, generative-ai, generative-ui, ide, mcp, multi-agent, react, rust, tauri
- Language: Rust
- Homepage: https://zynta-studio.vercel.app
- Size: 776 KB
- Stars: 2
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
🌌 Crafted with ❤️ by Zeroday
A next-gen, multi-agent powered Sovereign AI IDE. It doesn't just help you code — it codes alongside you, entirely on your local hardware.
> **Zynta Studio** is a full-stack, AI-powered development environment built from scratch with Rust & React. It integrates generative AI, decentralized agent orchestration, cryptographic code provenance, neural time-travel debugging, and an atomic virtual file system — all running **100% locally** with zero cloud dependency.
---
> [!WARNING]
> **🚨 EXPERIMENTAL & BETA SOFTWARE**
>
> This system is an actively evolving Agentic IDE.
> - **Action Warning:** Zynta Studio acts as an active DevOps Agent. It will execute Native Terminal commands, compile code, and run UI tests automatically.
> - **Zero-Egress Mode:** In Sovereign mode, absolutely zero data leaves your machine. All AI runs on local Ollama.
> - **Liability:** Use Zynta Studio at your own risk. Do not expose production secrets in your working directory.
---
## 🤔 The Problem
Traditional IDEs are passive tools. Even with AI copilots, the burden of architecture, debugging, and deployment remains on the developer. Context windows are limited, AI often breaks existing code, and your intellectual property gets sent to cloud servers you don't control.
## 💡 The Solution
**Zynta Studio v5.0** is an active participant in your development process. It uses a **Software Engineering Multi-Agent Protocol (SEMAP)** where specialized agents collaborate, debate, and write code entirely locally. It proves who wrote every line of code via a **blockchain provenance ledger**, and lets you **time-travel** through your application state to catch bugs before they happen.
---
## 📸 See It In Action
*(Replace this placeholder with a GIF or video showing Zynta Studio in action)*
---
🔥 What's New in v5.0 — Sovereign AI Release
### ⚡ Dark Glassmorphism UI
The entire interface has been **completely redesigned** with a premium 2026 aesthetic:
- **Animated nebula background** with shifting radial gradients
- **Frosted glass panels** — `backdrop-filter: blur(20px)` on every surface
- **Agent glow trails** — neon accent scanning lines being analyzed by AI
- **Glass buttons** with hover lift, gradient accents, and spring physics
- **Status dot pulses** — live heartbeat indicators for agents and systems
### 🧠 SEMAP Actor System (Rust)
Three specialized AI agents that understand your domain:
- **FrontendAgent** — Analyzes UI, component architecture, accessibility
- **BackendAgent** — Reviews API design, database schemas, security
- **DevOpsAgent** — Manages CI/CD, Docker, infrastructure as code
- Each agent has an autonomous **auto-fix loop** for error remediation
### 🌳 True AST Parsing
Native Rust parser (tree-sitter integration ready) that:
- Extracts functions, classes, imports from any file
- Generates live **Mermaid flowcharts** in the "Architecture Vis" tab
- Updates in real-time as you type
### 🔗 Native Git Orchestration
No more `git` CLI fumbling. Full native integration:
- `git clone` / `commit` / `pull` / `push` / `status` / `log`
- Repository info panel in the sidebar
- Remote tracking and diff visualization
### ⏰ Neural Time Travel Debugger
Scrub through your application's execution timeline:
- **Ring-buffer state recorder** capturing variable snapshots
- **Automatic drift detection** — AI spots when variables mutated unexpectedly
- Visual **gradient scrub bar** with drift markers
- Split-pane **memory snapshot** + **AI drift analysis**
### 🔒 Code Provenance Blockchain
Append-only SHA-256 chain that cryptographically proves:
- **`[USER-AUTH]`** — Every line you personally wrote
- **`[ZYNTA-GEN]`** — Every line the AI generated
- **`[HYBRID]`** — Lines you modified after AI generation
- Badges visible on every file tab. Chain integrity verifiable at any time.
### 🎮 Gamified Flow State
- **Flow Mode** — Silences all distractions, shows only the current function
- **Streaks & Achievements** — "The Bugslayer" (fix 10 bugs), "Clean Coder" (95%+ coverage)
- **Model Switching** — Fast model (Llama 3 8B, ~80ms) for simple tasks, Heavy model (Claude 3.5, ~2.1s) for architecture
---
🌟 Full Feature List
💾 Transactional VFS
Atomic file operations with Idempotency verification. Built-in Transaction Managers with time-traveling, snapshot-based Undo/Redo logic. "Infinite Undo" — rollback 10 files in 50ms.
📡 MCP Telemetry
Enterprise-grade observability via the Model Context Protocol. Prometheus metrics, KPI tracking, execution latency, and AI hallucination rate monitoring.
🤖 SEMAP Orchestration
Software Engineering Multi-Agent Protocol. Actor-model architecture mapping agents to Frontend, Backend, and DevOps. Includes Debate protocols for consensus.
⚖️ Agent Exchange (AEX)
Combinatorial Auctioning Engine. Distributes workloads to agents based on token capacity, context alignment, and operational cost.
✨ Inline Composer (Cursor-Style)
Native floating composer with Socratic Mentor Mode. Get guided hints instead of direct answers. Proprietary file locking prevents AI from seeing sensitive code.
🖥️ Live Artifacts (Claude-Style)
Real-time split-pane Preview. Cross-platform rendering for Web, iOS, Android, Linux, and Windows targets with device frame simulation.
🛡️ Red/Blue Teaming & CI/CD
Adversarial shadow agents run security scans in the background. Kubernetes self-healing CI/CD with auto-scaling.
💡 Terminal Listener
Monitors execution streams. Intercepts missing dependencies and prompts auto-install via winget/brew. Renders as premium glassmorphism toast.
🔒 Zero-Egress Mode
Cuts all external cloud APIs with a single toggle. All AI runs on local Ollama. PII Scanner scrubs context before any fallback.
🚀 Zynta Runner (DevOps)
Web: Playwright auto-tests. Android: ADB/Gradle compilation. Windows: PyInstaller EXE packaging. All from one button.
---
## 🏗️ Architecture Blueprint
```text
┌──────────────────────────────────────────────────────────────────┐
│ ZYNTA STUDIO v5.0 │
│ Sovereign AI IDE Core │
├──────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Sidebar │ │ Editor Area │ │ Live Preview │ │
│ │ • Explorer │ │ • Composer │ │ • Artifacts │ │
│ │ • Git Panel │ │ • AST Vis │ │ • Device Sim │ │
│ │ • Sovereign │ │ • Glow Trail │ │ • Charts │ │
│ │ • Streaks │ │ • Provenance │ │ │ │
│ └───────┬───────┘ └──────┬───────┘ └──────────────┘ │
│ │ │ │
│ ▼ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ AGENTIC TERMINAL │ │
│ │ • Execution Logs • Logcat/ADB • Time Travel │ │
│ │ • Telemetry • Shadow Agents │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
├──────────────────────────────────────────────────────────────────┤
│ RUST BACKEND (TAURI) │
│ │
│ ┌────────────┐ ┌──────────┐ ┌──────────┐ ┌──────────────┐ │
│ │ SEMAP │ │ AST │ │ Git │ │ Time Travel │ │
│ │ Actors │ │ Parser │ │ Native │ │ Debugger │ │
│ ├────────────┤ ├──────────┤ ├──────────┤ ├──────────────┤ │
│ │ Frontend │ │ Heuristic│ │ clone │ │ Ring Buffer │ │
│ │ Backend │ │ + tree- │ │ commit │ │ Drift Detect │ │
│ │ DevOps │ │ sitter │ │ push/pull│ │ State Replay │ │
│ └────────────┘ └──────────┘ └──────────┘ └──────────────┘ │
│ │
│ ┌────────────┐ ┌──────────┐ ┌──────────┐ ┌──────────────┐ │
│ │ Provenance │ │ VFS │ │ MCP │ │ LLM Engine │ │
│ │ Blockchain │ │ Engine │ │ Telemetry│ │ (Ollama) │ │
│ ├────────────┤ ├──────────┤ ├──────────┤ ├──────────────┤ │
│ │ SHA-256 │ │ Atomic │ │ Metrics │ │ Local Only │ │
│ │ Chain │ │ Snapshot │ │ Export │ │ Zero-Egress │ │
│ │ USER/AI │ │ Undo │ │ Prom │ │ PII Redact │ │
│ └────────────┘ └──────────┘ └──────────┘ └──────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────┘
```
---
🚀 Quick Start & Installation
> **🍼 DEPLOYING TO DESKTOP?** Read our **[Detailed Deployment Guide](DEPLOYMENT_GUIDE.md)** for a complete step-by-step walkthrough on compiling Zynta Studio into a native Windows `.exe` using Tauri!
**Prerequisites:**
- Node.js 18+ installed
- Rust toolchain installed (`rustup`)
- For local AI: [Ollama](https://ollama.ai/) with `llama3` model
**1. Clone the repository**
```bash
git clone https://github.com/webspoilt/zynta-studio.git
cd zynta-studio
```
**2. Install Dependencies**
```bash
npm install
```
**3. Run the Development Server**
```bash
npm run tauri dev
```
### 📦 Packaging into a `.exe` (Windows Executable)
We use **Tauri** to bundle this into a single, blazing-fast native executable (~15MB).
```bash
# Build the production application
npm run tauri build
```
✨ Your executable will be in: src-tauri/target/release/bundle/nsis/ ✨
---
🤝 Open Source Contribution
We believe the future of AI belongs to the Open Web. This operates under the **GPL-3.0 License**.
**You cannot steal this model and hide the code.** But you ARE fully encouraged to fork and build your own custom IDE — as long as you keep your derivative work Open Source!
### 📝 How to Contribute
1. **Fork** the repository ✨
2. Create your Feature Branch: `git checkout -b feature/AmazingFeature`
3. Commit your changes: `git commit -m 'feat: Add AmazingFeature'`
4. Push to the branch: `git push origin feature/AmazingFeature`
5. Open a **Pull Request** 🚀
**We need help with:**
- Wiring real LLM endpoints (OpenAI, Anthropic, Groq)
- Full tree-sitter grammar integration for 10+ languages
- Native `git2` replacement for the system git calls
- Expanding the provenance ledger with digital signatures
---
📬 Let's Connect (The Author)
Developed with passion by Zeroday. I love building tools that break boundaries.
