Piye Code

Four Doors one app.

A code editor with an agent that knows your whole project.

Windows is coming along with Arcade.

Download for Mac and Linux

bloomVisualCodeStudioLA

Explorer···

bloom

.github

app

(shop)

api

orders

sales

TSroute.ts

⚛layout.tsx

⚛page.tsx

components

lib

server

PYdb.py

PYsales.py

services

sales

GOsales.go

tests

{}package.json

M↓README.md

Outline

Timeline

TSroute.tsPYsales.pyGOsales.go

appapisalesroute.tsGET

1import { NextResponse } from "next/server";

2import { db } from "@/lib/db";

3import { requireUser } from "@/lib/auth";

4import { startOf, today } from "@/lib/time";

6export async function GET(req: Request) {

7 const user = await requireUser(req);

8 const { searchParams } = new URL(req.url);

9 const day = searchParams.get("day") ?? today();

11 const orders = await db.order.findMany({

12 where: { shopId: user.shopId, createdAt: { gte: startOf(day) } },

13 select: { total: true, status: true },

14 });

16 const total = orders.reduce((sum, o) => sum + o.total, 0);

18 return NextResponse.json({

19 day,

20 total,

21 count: orders.length,

22 });

23}

Problems0OutputDebug consoleTerminalPortsPiyeClassic

~/bloom❯

Sales endpoint

TSroute.tsmainProject health

Add a paid-only total to the sales endpoint and cover it with a test.

Reading the project…

Add more or correct it: it reads this at its next step

BuildClaude Sonnet 5MediumAuto

Piye Code01 / 04

01An agent that plans, builds and diagnoses like a senior engineer, with project memory.
02Language support set up automatically for 22+ languages, plus a debugger.
03A command-block terminal.
04Models: Claude, GPT, Gemini, Grok, Mistral. Your own keys. Local models with Ollama.

Meet Piye Code

PiyeCodeisafullcodeeditorwithanengineerbesideyou.Openanyprojectandtheagentalreadyknowshowitfitstogether:itplansthechange,writesit,runsthechecksandtellsyouwhatitfound.

Everything a serious editor needs is there from the first launch: language support, a real debugger, git, a terminal and your choice of model, including ones that run on your own machine.

Made for

Developers
Engineering teams
Students
Builders who outgrew no-code

Language support set up automatically for 22+ languages, plus a debugger.A command-block terminal.An agent that plans, builds and diagnoses like a senior engineer, with project memory.Models: Claude, GPT, Gemini, Grok, Mistral. Your own keys. Local models with Ollama.Pop-out panels and 32 themes.An operations panel with the live status of your services.Bring Claude Code or Codex.

01Watch it

An operations panel with the live status of your services.

GitHub

Vercel

Railway

Stripe

Operations · liveAll systems up

githubCI passed on main · 2m 14s

Streaming from your project

What itcan do.

08 things Piye Code does for you, in plain words.

01An agent that knows the projectIt plans, builds and diagnoses like a senior engineer, and remembers how your project works.
0222+ languagesAutocomplete, errors as you type and go to definition, set up for you.
03A real debuggerBreakpoints, step through, and see every value while your code runs.
04Command-block terminalEvery command and its output in its own block, easy to read and reuse.
05Your choice of modelClaude, GPT, Gemini, Grok or Mistral, with your own keys or local models.
06Git built inChanges, branches and commits without leaving the editor.
07Operations panelThe live status of your hosts, payments and services, in one place.
08Make it yoursPop-out panels and 32 themes.

Underthe hood.

Simple on the surface. Serious technology underneath, so what you make is real.

01Language serversThe same engines big editors use for code smarts, installed automatically per language.

02Debug Adapter ProtocolThe standard way editors talk to debuggers, so the debugger works across languages.

03OllamaRun models on your own computer, with no internet and no bill.

04Claude Code and CodexAlready use one? Bring it in and run it inside Piye.

The full tour

Every partof the IDE.

Piye Code is not a fork of another editor. It is built on Monaco, the editing engine inside VS Code, with the standard language servers, so it feels familiar from the first minute.

The editor

Tabs and splits, a minimap, sticky scroll and matching bracket colours. Problems show as you type, and your project's own Prettier and ESLint decide the style, so the editor agrees with your command line.

Open any file with Cmd+P, split right with Cmd+\
Format, sort imports and apply safe fixes on save
Changed lines and who changed them, beside the code
Markdown preview, Jupyter notebooks and images open in place
Your own snippets, with their own triggers
Merge conflicts side by side, one choice per conflict

Language intelligence

Each language gets its standard language server, downloaded the first time you open one of its files, pinned to a known version and checked before use. Nothing to install by hand.

Errors, completion, go to definition, find references and rename
Quick Fix with Cmd+., Organize Imports and Fix All
A settings page per language: its server, its options, its log
Inline hints, CodeLens and semantic colours, each on or off

Tab and inline edit

Gray suggestions appear as you type, and Tab takes them. Select some code, press Cmd+K and describe the change: it's made in the editor, so Cmd+Z takes it back.

Suggestions come from a model built for fast completion
Each one costs a few hundredths of a credit
Cmd+K inside a function takes the whole function
Secret files like .env are never sent to the AI

Run and debug

Set a breakpoint in the gutter and run. When it stops you get the call stack, the variables in every frame, and a Debug Console that evaluates expressions while you're paused.

Debug Python File, Debug Go File and more, from the command palette
Launch configurations live in .piye/launch.json, ready to commit
Step over, into and out, continue, pause and stop
Breakpoints are kept between sessions

Tests

The Testing view finds your tests by file. Run one test, a file or all of them, and read the failure's output right where it failed.

Jest, Vitest, pytest, go test, cargo test, Gradle, Maven, dotnet test, swift test, PHPUnit and dart test
Run Build Task (Cmd+Shift+B) uses the project's own build
The agent can triage failing checks or cover your changes with tests

The terminal

Two styles, both your real shell. In Piye style each command is a card with its output and how it ended. Classic is the familiar terminal, with split panes.

A running command gets the full terminal, so prompts and menus work
Next suggests commands read from the project's own files, with no AI
Deploy and reset commands go into the box to read first, never run straight away
Send a failed command and its output to the agent in one click
Pull the terminal off into its own window with Cmd+Shift+T

Source control

Git without leaving the editor: stage and commit, amend, sign off, switch and create branches, pull and push, with side-by-side diffs.

Cmd+Enter commits; with nothing staged, every change goes in
Pull by merge or by rebase, your choice in Settings
The Timeline shows the open file's history
Discarding changes always asks first

Search

Find in the file or across the project, with match case, whole word and file filters. To find something by what it does, ask the agent instead.

Smart case: it ignores capitals until you type one
Replace in one file, or everywhere at once
"Where do we charge the card?" is a question for Ask mode

Your layout

Drag panels to swap them, hide them, or pull the agent, Operations and the terminal into windows of their own. Reset Workbench Layout puts everything back.

Three layouts: Editor + Panels, Editor Only and Agent Focus
Interface size changes Piye's screens, never your code's font
32 colour themes, light and dark, and three icon themes

Languages

Every language,set up for you.

The language servers, formatters, debuggers and test runners Piye sets up, language by language. Each one downloads the first time you need it.

Language	Language server	Format	Debugger	Tests
TypeScript, JavaScript	typescript-language-server	Prettier	JavaScript debugger	Jest, Vitest
Python	Pyright	Ruff	debugpy	pytest, unittest
Go	gopls	gofmt	Delve	go test
Rust	rust-analyzer	rustfmt	lldb-dap	cargo test
C, C++, Objective-C, CUDA	clangd	clang-format	lldb-dap	make test
Java	jdtls	Yes	java-debug	Gradle or Maven
Kotlin	Kotlin language server	Yes	Yes	Gradle
C#	Roslyn	Yes	netcoredbg	dotnet test
Swift	sourcekit-lsp	Yes	lldb-dap	swift test
PHP	phpactor	PHP CS Fixer	Not yet	PHPUnit
Dart	Dart analysis server	dart format	Yes	dart test
Shell	bash-language-server, with ShellCheck	shfmt	—	—
SQL	sqls	sql-formatter	—	—
HTML, CSS, SCSS, Less, JSON	VS Code's HTML, CSS and JSON servers	Prettier	—	—
YAML	yaml-language-server	Yes	—	—
TOML	Taplo	Taplo	—	—
Markdown	Marksman	Prettier	—	—
Dockerfile	docker-langserver	Yes	—	—
Tailwind CSS	Tailwind CSS language server	—	—	—

C and C++ debugging works for a single file and for Makefile projects. Kotlin's server comes from JetBrains; when a newer build is out, Piye offers it and asks first, because it's large.

The agent

Four modes,one engineer.

The mode menu sits under the chat box, beside the model. A new chat starts in Build, and you can change the mode between messages.

01Default
BuildDoes the work: reads what it needs, edits files, runs commands and checks, then says what it did and what's left.
- "Add rate limiting to the login route"
- "Make the test suite pass"
02Read only
AskLooks wherever the answer is: this project, your other repositories, this computer and the web. It changes nothing.
- "How does auth work here?"
- "Which services does this app call?"
03Plan first
ArchitectReads the project and writes a plan you agree before anything changes: the structure, the files, the trade-offs and the risks.
- A feature with moving parts
- A refactor across many areas
04Root cause
DebugReproduces the bug, finds the cause, makes the smallest fix, then runs the same check again to show it's gone.
- A failing test or a stack trace
- "The checkout total is wrong"

What it can do

Like a seniorengineer at your keyboard.

On Piye credits, the agent gets Piye's full set of tools. On your own key or a local model, it has the standard IDE tools: files, the terminal, the editor and the chat.

01Read and searchThe project, and any folder on your computer, except the places that hold secrets.
02Edit filesCreate, rename and delete, with every change listed and every change undoable.
03Run commandsIn the command sandbox: dev servers, type check, lint, tests and the build, watching their output.
04Use the language toolsOutline, go to definition, find references, and rename across files.
05Look at your appOpen the preview, read its errors, click through it, and run it on simulators and phones.
06Read the webSearch the web, and read the docs pages it finds.
07Know the computerThe apps and command-line tools you have, so it uses them instead of telling you to.
08Use your connectionsMCP servers like GitHub, a database or Figma, once you connect them.
09Read OperationsAsk why production is failing, and it starts from the real alerts.
10Work across projectsChange another project on your computer from the same chat. It asks once, and each change there has its own Undo.
11Hand off to helpersSplit work across helpers that run in parallel, in this project or another one.
12Take a correction mid-taskType while it works and press Enter. It reads your message at its next step, without stopping.

Review, Auto and undo

Nothing landswithout your say.

The Review and Auto switch sits beside the send button. Either way, every change has an Undo, and a reply's Undo puts back every file it changed.

	Review (the default)	Auto
File edits and new files	Wait for your Accept, file by file	Apply as they land
Deleted files	Wait for you	Go to Piye's trash, so they can be restored
Commands	Wait for you	Run at once, in the command sandbox
Dangerous actions	Always wait	Always wait

Dangerous means: Git push, deploys and publishing, rm and sudo, .env and other secret files, anything that can delete database data, a program's own delete command, and commands that reach outside the project or the sandbox.

Models, keys and effort

Your model,your way.

Each chat keeps its own model. Effort sets how long a thinking model reasons: Low for quick edits, Medium for everyday work, High for hard problems, Max for the hardest.

Where the AI runs	Who pays	What the agent can do
Piye credits (signed in)	Your plan's credits	Piye's full agent: every tool
Your own API key	Your provider, directly. Piye adds nothing	The standard IDE tools: files, terminal, editor and chat
Local models (Ollama)	Nothing	The standard IDE tools

Keys for Anthropic, OpenAI, Google, xAI and Mistral work on every plan, with or without a Piye account. Signed in, credits come first and a key covers the models your plan doesn't include; Only API keys runs everything on your keys. Every reply shows what it used, in credits or in dollars on your key.

Models

Models fromfive makers.

The model menu groups models by maker, recommended ones first, and says what each is for and what it uses. When a maker retires a model, it leaves Piye's lists that day.

Anthropic

Claude Opus 5.5
Claude Sonnet 5.5
Claude Haiku 5.5
Claude Fable 5.1

OpenAI

GPT-6 Astra
GPT-5.6 Sol
GPT-5.5
o3 Pro

Google

Gemini 4 Argon
Gemini 3.1 Pro
Gemini 3.8 Flash

xAI

Grok 4.7
Grok Build 0.1

Mistral

Mistral Large 4
Mistral Large 3
Devstral 2

On this computer

Any model you've pulled with Ollama. Free, and nothing leaves the machine.

Ollama

Rules, memory and skills

Teach it once.It remembers.

The agent reads your project's rules at the start of every chat, keeps its own notes between chats, and uses skills for the jobs you repeat. A project set up for another tool works as it is.

Rules it reads

Conventions, commands, things to avoid. In a monorepo, each app's own rule files are read too.

.piye/rules.md
.piye/rules/
AGENTS.md
CLAUDE.md
GEMINI.md
.cursorrules
.windsurfrules
.github/copilot-instructions.md
.cursor/rules/*.mdc
.claude/rules/*.md

Rules it saves

Say "always run the type check before you're done" and it saves a working rule, shown in the chat with Undo.

.piye/rules/working-rules.md

Memory

What it learned, decisions made, where things are. It stays on your computer and is never sent by Handoff.

.piye/memory/notes.md

Skills

A folder with a SKILL.md: the same open format Claude Code and Codex read. From the project, from OXP, or built in for the stacks Piye knows:

Next.js
Expo
Angular
NestJS
Vite
React with Vite
Turborepo
FastAPI
SwiftUI
Jetpack Compose

MCP and the Marketplace

Connect the toolsyou already use.

Press Connect: most servers sign you in through your browser, keys go into your computer's secure storage, and Piye writes the configuration. The first time the agent uses a tool in a chat, it asks: Allow once, Allow for this chat, or Don't.

Design

Figma
Framer
Canva
Webflow

Collaboration

GitHub
Notion
Linear
Slack
Jira
Confluence
Asana
monday.com
Discord
HubSpot

Infrastructure

Vercel
Cloudflare
Railway
Hostinger
Docker
Kubernetes
AWS
Sentry
Datadog

Databases

Postgres
Supabase
MongoDB
Redis
SQLite
Prisma
Firebase

Payments and identity

Stripe
Auth0
Clerk
WorkOS

Mobile and testing

Expo
Playwright
Puppeteer

Your own

Add a server by command or address, or edit mcp.json yourself. A project can list its own in .piye/mcp.json.

mcp.json
.piye/mcp.json

Ship it and watch it

From the editorto production.

Deploy, the Apps view and Operations live in the same window as your code, so shipping and fixing never means twelve dashboards.

Deploy

Choose a host, sign in once, and deploy. Piye runs each host's own command-line tool for you; you don't install them first.

Quick deploy: Vercel, Cloudflare Pages, Railway, Hostinger
EU sovereign: Hetzner with Coolify, OVHcloud, Scaleway
Self-hosted Coolify, AWS Amplify and Google Cloud Run
Deploy Now, or a Preview deploy with its own address
Environment variables listed by name; values are never shown

Docker

Generate a Dockerfile when the project has none and review it with the agent. See images, containers and Compose services, push to a registry, and ship a container.

Build and ship to Cloud Run, Railway or Scaleway
Docker Hub sign-in in the browser, with a device code

Apps and devices

The Apps view recognises the apps in your project and runs them: phone apps, desktop apps and websites, one by one in a monorepo.

Expo, React Native, Capacitor, Swift and Kotlin
Electron and Tauri, previewed in a MacBook or Windows frame
iPhone and iPad simulators, Android emulators and your own phones
Piye sets up Android itself; for iPhone you install only Xcode

The stores

For Expo apps, the Stores tab signs in to Expo, runs EAS cloud builds and submits to the App Store and Google Play. Desktop signing and notarizing for the Mac is on the same tab.

App Store Connect API key, or a Play service account key
Submit to App Store sends the build to TestFlight
Expo updates go out over the air

Operations

Reads the hosts, CI and app stores you're signed in to, and shows real alerts by level: critical, warnings and info. It checks every five minutes and holds still in between, so you can read it.

It only reports what the services report. It never invents issues
If a host didn't answer, it says it couldn't fully check
Connect cloud adds uptime, response time, certificates and security headers, with email alerts

Safe by default

Real computer.Firm rules.

The agent reads, runs and browses on your real machine, so Piye puts a few firm rules around it and asks at the moments that matter.

01Trust this folder?A folder from outside Piye opens and edits normally, but none of its programs run (type check, lint, MCP servers, Git) until you choose Trust.
02
The command sandboxThe agent's commands can only write inside the project and the tools' caches, and never read where your computer keeps secrets.
- Mac: always
- Linux: with bubblewrap
- Windows: not yet
03Send data out?When the agent wants to open an address that carries data, Code asks first. Docs, searches and package sites never ask, so normal lookups don't stop.
04Your secretsKeys and sign-ins live in the Keychain or the system keyring, never in your project. .env files are read as names only.
05Privacy ModeBlocks Piye Cloud and your own keys, so nothing about your code leaves the computer. Local models through Ollama keep working.
06No trackingThe app has no usage tracker and no crash reporter, and turns off the telemetry of the tools it runs for you. Your projects never train public models.

Keyboard

The keysyou'll use daily.

Piye's keymap on a Mac. On Windows and Linux, use Ctrl where a Mac uses Cmd.

CmdPGo to file
CmdShiftPRun any command
CmdShiftAShow the agent
CmdLNew chat
CmdKInline edit
Ctrl`Show the terminal
CmdShiftFFind in files
CtrlShiftGSource control
CmdShiftDRun and debug
CmdShiftOOperations
CmdShiftXMarketplace
Cmd\Split the editor
CmdBShow or hide the side panel
CmdShiftBRun the build
Cmd.Quick fix
ShiftAltFFormat the file

Questions

Goodquestions.

Is Piye Code a VS Code fork?

No. Its editor is built on Monaco, the editing engine behind VS Code, and its language features use the standard language servers. Much of what other editors add with extensions is built in.

Can I use my own API keys?

Yes, on every plan, with or without a Piye account: Anthropic, OpenAI, Google, xAI and Mistral. Your provider bills you directly and Piye adds nothing. On your own key the agent has the standard IDE tools; Piye's full agent runs on Piye credits.

Can it work without sending my code anywhere?

Yes. Run models on your own computer with Ollama, and turn on Privacy Mode: it blocks Piye Cloud and your own keys, so nothing about your code leaves the machine.

Is my code used to train AI?

No. We don't use your projects to train public models, and the app sends no usage tracking. Your projects, chats and keys stay on your computer.

My project is set up for Cursor or Claude Code. Will it work?

As it is. Piye reads AGENTS.md, CLAUDE.md, GEMINI.md, .cursorrules, .windsurfrules, Copilot's instructions and the .cursor and .claude rule folders, plus skills in .claude/skills and .agents/skills.

Can I run Claude Code or Codex inside Piye?

Yes, with your own sign-in. They run on your computer, are billed by their makers, and work with Piye's standard IDE tools. Bring your chats imports conversations from Claude Code, Cursor and Codex so Piye's agent can carry on.

Which computers does it run on?

Mac, with Apple silicon or Intel, signed and notarized by Apple, and Linux, as .deb and .rpm. Windows is coming along with Arcade.

What does it cost?

The app is free, with every feature on every plan. AI runs on credits: Starter gives you 750 free credits, and again every 6 months. Or use your own keys, or local models at no cost.

Does Piye change my repository?

Only with the changes you or the agent make. Piye keeps its notes in a .piye folder; delete it and the project still builds and runs. Your chats stay in .piye/memory, which Piye keeps out of Git.

Four Doorsone app.

VisualPiye VisualDescribe it, see it, click to change it. Web and phone apps.ArcadePiye ArcadeTurn an idea into a real game. Play it on your phone in seconds.CodePiye CodeA code editor with an agent that knows your whole project.StudioPiye StudioMany agents, many projects, side by side.

Downloadfor Mac and Linux.

Download for Mac and Linux

Windows is coming along with Arcade.