History

Changelog

Everything that changes in Yuli Code, release by release.

0.0.99

CurrentDownload 0.0.99

The first public release of Yuli Code, free and in BETA: a desktop IDE where AI works with you without taking control away from you. It brings together everything the IDE already does today: agents on your own account, sensitive-data masking, Six Sigma measurement against the previous version, end-to-end security and the tools of a full IDE.

Agents and AI

  • Subscription mode: work with your own Claude Code, Kiro, Codex or Antigravity, on your account and unmodified. Yuli never touches your credentials and never downloads or redistributes those agents.
  • Built-in Claude Code with its real terminal: Yuli View (formatted conversation, changed files, verification and a live plan) or full-screen Claude View, with a model and effort picker and your plan usage.
  • Kiro, Codex and Antigravity over ACP: Yuli acts as an ACP client and streams the reply, reasoning, tools, permissions and plan. Each agent keeps its own conversation, mission and changes window.
  • Platform mode with your keys: Anthropic, OpenAI-compatible providers, Gemini, xAI, DeepSeek, Bedrock, Vertex and local models (Ollama, LM Studio, vLLM or llama.cpp), with configurable extended reasoning.
  • Yuli as an MCP server (yuli-mcp): build, tests, verification, code, REST, database, Web Studio, mission and IDE commands as yuli_* tools, reachable only over loopback with a session token.
  • MCP connectors for GitHub, GitLab, Jenkins, CloudBees CD/RO, Jira, SonarQube and documents: reads run freely; writes ask for authorization and never run unattended.
  • Question and permission cards at the end of each turn, proposals with their diff and an activity timeline of what the agent is doing at every moment.
  • Fewer tokens: end-to-end prompt caching, budgeted context, only the tools that apply to the project and independent reads in parallel, with a token, cost and budget meter.
  • Project skills, prompts, hooks and rules, with 14 built-in skills, a dedicated editor and project and team memory.

Missions, phases and agent team

  • Missions saved with the project: request, requirements, acceptance criteria, decisions, plan, files touched and a handoff point. The goal is never lost, however long the conversation gets.
  • An 8-phase lifecycle: analysis, design, planning, implementation, measurement, testing, review and delivery.
  • Unattended mode: the agent asks only during analysis, then decides with the recommended option, rejects anything destructive and never pushes to the remote without you.
  • Agent team: a lead agent publishes a task graph with one role per task (backend, frontend, database, testing, devops or documentation) and sub-agents work in parallel, each in its own isolated copy.
  • Integration and cross-review: tasks are merged into a mission branch, tested on the integrated result and reviewed as a whole by a reviewer agent. Your working copy is untouched until you authorize it.
  • Background tasks in an isolated copy of the repository, with token and cost caps, applied as a patch or a merge.
  • AI Changes: every agent change is explained in Written, Visual or Code mode by a deterministic risk engine, gets tested and offers "Ask the AI for the cause".
  • Changes window with a file-by-file diff, accept or reject per hunk, checkpoints and one-step undo of a whole task.

Sensitive data and privacy

  • Local first: code, index and agent state live on your machine. Only the AI you choose goes out, with no intermediate servers.
  • Typed secret masking: keys, tokens, JWTs, connection strings and passwords are replaced with a marker carrying their type and length before they reach a model, a log, an MCP server or a commit. The real value comes back only when writing to your project.
  • Personal data (PII) markers: emails, phone numbers, national IDs (DNI/CUIT, RUT, CPF, NIF), IBAN, CBU and card numbers are detected with validators and reach the model as a marker or as a stable synthetic value.
  • Zero storage of sensitive data: original values live only in memory and are wiped securely, traces are redacted before they touch the disk and nothing is kept in plain text.
  • Credentials vault: finds .env files, keys and tokens in code and, with your consent, moves them to an encrypted area outside the repository with .env.example and .gitignore; it warns when they need rotating and injects values only at run time.
  • Corporate vaults: HashiCorp Vault, Azure Key Vault, AWS Secrets Manager and GCP Secret Manager, with ${secret:…} references resolved only at run time.
  • Files the agent never reads: .env, keys, certificates, credentials and .ssh/, not even through the terminal; the rule applies to Yuli and to subscription agents.
  • Prompt-injection defense against instructions hidden in web pages, files and MCP or terminal output.
  • Single egress point: a local gateway through which model calls from Yuli, Claude Code, Codex, Kiro and Antigravity pass, with signed organization policies and a chained audit log.

Quality, Six Sigma and governance

  • Measurement against N−1: every metric is compared with the previous version (with Git, every commit is a version) and marked ▲, ▼ or =. Never backwards, always forwards.
  • A-to-E rating over ten ISO/IEC 25010 attributes and 14 clean-code practices, each with its figure, its target and where to act first.
  • Six Sigma and statistics: DPMO, sigma level, Cpk, FPY/RTY, control chart, DMAIC, confidence intervals and trends with forecasts.
  • Measurement phase: the agent measures the code it touched and goes back to implementation until it improves, before moving on to testing.
  • Metrics in the editor: cyclomatic and cognitive complexity, maintainability index and coverage above every method, with hints on the exact line of each magic number or piece of dead code.
  • Refactor or evolve?: criteria, decision matrix and economic case with COCOMO II, ROI and PERT.
  • Quality contract versioned in .ai/contract.json, with four criticality levels, applied the same way to people and agents.
  • A single gate for pre-commit, commit-msg, pre-push and CI: secrets, cheating in tests, change size, protected paths and AI attribution.
  • Governance Center with 10 tabs: contract, gates, sensitive data, analysis, design (ADR, STRIDE, C4), measurement, testing, supply chain (SBOM, SLSA), delivery (DORA) and agents.
  • Independent review by a model from a different family, and the same rules for every agent: CLAUDE.md, AGENTS.md, Kiro, Antigravity, Cursor, Copilot and Gemini.

Security

  • Local Security Center: vulnerable dependencies, code vulnerabilities, resource leaks, race conditions and licenses, without sending your code anywhere. OSV.dev and AI review are optional.
  • Project sandbox: the agent only creates, moves or deletes inside the open project; other folders are granted read or read-write access and everything else asks for confirmation.
  • Risk-based permissions with the Cautious, Balanced and Autonomous presets, and "Allow for this turn" for subscription agents.
  • Project trust: restricted mode never runs repository code to analyze it.
  • Hardened Electron: app:// protocol with a strict CSP and locked-down channels and permissions.
  • Updates signed with Ed25519, an SBOM per release and crash reports only if you turn them on.
  • Up-to-date Rust engine: every dependency on its latest version, TLS through rustls only with the system verifier, symlink-safe archive extraction and audits with cargo audit and cargo deny.
  • Identity and audit: OIDC with PKCE (Entra ID, Okta, Google), roles and a hash-chained audit log that exports to your SIEM.
  • Sandboxed plugins with declared permissions, digital signatures and network access limited to the domains they declare.

Editor and languages

  • Managed language servers for Java, TypeScript and JavaScript (real tsserver), CSS, Python, Rust, Go, Kotlin, C#, PHP, Ruby, C/C++, Bash and Dockerfile, installed with your permission and without a system Node or npm.
  • Highlighting for dozens of languages, completion, code lens, formatting and live diagnostics with distinct severities.
  • Vim and Emacs modes, Emmet, snippets, EditorConfig and format on save.
  • Notebooks inside the editor.
  • Split view to the side or below with files from the project, an external library or another project, plus a side-by-side or inline file diff.
  • Legacy Java: Hibernate XML mappings, a per-language .properties message editor, XML formatting and unmigrated Ant and Eclipse projects.
  • Previews for Markdown, OpenAPI/Swagger and documents.
  • AI completion off by default: turn it on when you choose, with the provider and model you prefer.

Code intelligence and navigation

  • Navigation engine in Rust with an in-memory index, lock-free reads, streamed results and cancellation.
  • Near-instant Ctrl+Click: the target is resolved while the cursor rests on the symbol.
  • Definition, implementations and usages, call tree and type hierarchy, always to the exact line; Lombok-generated accessors lead to the field that produces them.
  • Navigation history, bookmarks, file structure and global search, including Shift+Shift.
  • Compact references panel with read/write, generated-code and import filters.
  • Refactorings: extract method or variable, inline, move class, rename with an impact preview and change signature.
  • Browsable external libraries (source, decompiled or outline), a JAR index and your own jars even when Maven or Gradle cannot run.
  • Full-stack map: backend endpoints ↔ front-end HTTP calls, with navigation and contract.

Run, debug and test

  • JVM debugger with conditional, hit-count, logpoint and exception breakpoints, hot swap and a real Java evaluator: operators, method calls and conditions that never fail silently.
  • DAP debugging for Python (debugpy), Go (Delve) and .NET (netcoredbg), Node with source maps and the browser over CDP; adapters are installed with your consent.
  • ▶ in the gutter for Python, Go, .NET and package.json scripts.
  • Every kind of build: Maven, Gradle, Ant, sbt, Bazel, Python with pip, Poetry, uv, Pipenv or Hatch, and Node with npm, yarn, pnpm or bun.
  • Application servers: Tomcat, Jetty, JBoss/WildFly and WebLogic, with exploded deployment and a console that links every error to its file and line.
  • JVM diagnostics: thread dumps with deadlocks, memory histogram, heap dump and a Flight Recorder profiler.
  • Test explorer and coverage in the editor gutter.
  • Toolchains: detects JDK, Maven and Gradle and offers to download whatever is missing.

Databases

  • Engines: Oracle, SQL Server, MySQL, MariaDB, PostgreSQL, MongoDB, Redis, Cassandra/Scylla, DB2 and SQLite.
  • Agent access per connection: No access, Queries only (the default, with a row limit) or Super permissions, where every statement is approved and never runs unattended.
  • True read-only, MongoDB and Redis included, with a server-side read-only session per engine and an optional read-only account.
  • Sensitive columns detected without AI from naming conventions in several languages (financial data such as balances included), with team rules, and masked in the agent's queries.
  • No shortcuts: command-line database clients and driver scripts are blocked for the agent.
  • SQL and PL/SQL console with schema-aware completion, a tree execution plan, package and trigger source, and export to CSV or Excel.
  • TLS on every driver and passwords stored in the system keychain.

Git, CI/CD and DevOps

  • Full Git client: stage and discard per hunk, graph log, branches and conflicts in a three-pane editor with an explained suggestion from the agent.
  • Commit, push and pull in the background, with no background polling: fetch only happens when you ask for it.
  • CI: GitHub Actions, GitLab CI and Jenkins, with pipeline status, a log viewer that jumps to the first error and "Explain and fix".
  • Full Jenkins: folders, multibranch, live console, stages, approvals and estimated progress, with real tools for the agent.
  • CloudBees CD/RO in read-only mode: projects, pipelines, environments, releases and the Kubernetes workload.
  • Jira connected, with real tools for the agent.
  • Containers: images, compose, logs, pods, deployments and port forwarding with Docker and Kubernetes.
  • Trusted servers: internal servers over HTTP or with your own certificates, always with your confirmation.

Web Studio, REST and diagrams

  • Web Studio: a front-end index (React, Vue, Angular, HTML and JSP), architecture graphs and impact analysis.
  • Design Studio: per-device designs with review states, versions, a Design System and design-to-code and code-to-design.
  • No-run preview of a component, a page or the whole project, with an API simulator fed by OpenAPI or saved responses.
  • Embedded preview with an element ↔ component ↔ code inspector, console, network, screenshots and visual comparison.
  • Compound: starts the full-stack application in order, with health checks, unified logs and masked secrets.
  • REST client: collections in the project, several hosts per collection and credentials in the encrypted store.
  • Diagrams: system, business, class and sequence diagrams, a method flow graph and Mermaid in the chat.
  • Accessibility: static WCAG-based audit.

Collaboration and remote work

  • Live Share: TLS with a pinned certificate, 128-bit tokens, approval and per-guest permissions, with no secrets shared.
  • Remote development on WSL, SSH or containers, with three-way sync that never overwrites changes.
  • Remote environments for the agent: commands, logs, transfers and deployments by connection name, with approval, SSH bastion and redacted output.
  • Team settings versioned with the project: templates, commit convention, severities and team memory.

Interface and performance

  • Hextech chat: the backdrop of the Yuli, Claude Code and Kiro chats becomes brass gears around hexagonal energy cores, over a faint hex lattice with cells that light up.
  • Text always wins: the reading column dims the backdrop so messages stay sharp, in dark and light themes.
  • Same performance budget: half resolution, 12–20 fps, pre-drawn sprites, paused off screen and no animation with “reduce motion”.
  • Redesigned frame: one bar on top, one rail, one bar at the bottom and the Launcher, with project tabs on their own row.
  • Guided first run: language, theme, AI mode, license and privacy; reopen it from Help › Initial setup.
  • 8 languages in the interface and engine messages: Spanish, English, French, Portuguese, German, Chinese, Turkish and Romanian.
  • Accessible: light and dark themes with AA contrast, keyboard-friendly modals, a command palette and fully remappable shortcuts.
  • Fast on large projects: virtualized long lists, a WebGL terminal, split view without reloads and performance budgets.
  • Robust: errors isolated per region and always visible, a warning with backup when closing with unsaved changes, and restorable terminals.
  • Report a problem: builds a .zip with no code or conversations and with keys redacted, sent only when you send it.
  • Native notifications and a sound when builds, tests and tasks finish, real autosave and a resource monitor.

Distribution and licenses

  • Portable build for Windows x64: runs without installing; the first launch unpacks the app and later launches start instantly.
  • Free BETA license with every feature unlocked, signed with Ed25519, verified offline and activated online at yuliforge.com.
  • Verifiable download from yuliforge.com, with its SHA-256 and the release's CycloneDX SBOM.
  • Complete documentation at yuliforge.com/docs, in all 8 languages.
  • Legal and security: EULA, third-party notices, security policy and incident response procedure.
  • Delivery verified by CI: types, ESLint, interface and engine tests on Linux, Windows and macOS, an interface ↔ engine contract test and an end-to-end smoke test.