The native desktop version of Avnac, a design canvas for layouts, posters, social graphics, and visual documents.
Desktop port maintained by striker561 & d3uceY
Designed on the browser, openly now built for desktop.
Upstream Notice: The
mainbranch of this repository is a mirror of the original web app by @akinloluwami at akinloluwami/avnac. All desktop-specific work lives on thestudiobranch, which is the default branch of this fork.
Avnac Studio is a native desktop app built with Wails + Go. It is not a browser tab, and it is not Electron.
| Avnac Studio (desktop) | Avnac (web) | |
|---|---|---|
| Runtime | Native Wails + Go binary | Browser / Node backend |
| Memory usage | Very low - no Chromium process overhead | Browser-dependent |
| Executable size | Lightweight single binary | N/A (web app) |
| File storage | Native OS app data directory | IndexedDB (browser storage) |
| Media proxy | Built directly into the app binary | Separate backend service |
| HTTP backend | None required | Elysia backend for media, Unsplash, auth |
| Startup time | Fast - no cold boot of a server | Depends on backend startup |
| Offline use | Fully offline after install | Partial |
| Export | Native file save dialogs | Browser download |
In short: Avnac Studio starts fast, uses very little memory, ships as a light executable, needs no running HTTP backend, and persists your files to the OS natively - not to your browser.
- Create canvases from presets or custom dimensions
- Manage files from the Files screen - open, duplicate, rename, delete, import, and download workspace data
- Autosave to native app storage on every change - no manual saving required
- Edit text, shapes (rectangles, ellipses, polygons, stars), lines, and arrows directly on the canvas
- Add and crop images from local uploads or Unsplash
- Remove image backgrounds with one click
- Multi-select, group/ungroup, reorder layers, and align objects
- Resize, rotate, and position elements with precision controls
- Full layer panel with visibility and ordering controls
- Background fill - solid, gradient, or image
- Blur, opacity, corner radius, and shadow controls per element
- Stroke and paint popover controls
- Text formatting: font family (including Google Fonts), size, weight, alignment
- Build documents across multiple pages in a single workspace
- Name pages, switch between them, and double-click a tab to rename
- Per-page state is stored independently in native storage
- Import and export individual pages or entire workspaces as portable files
- AI agents draft and test on named pages in the open project instead of starting a new file
- Embed nested vector-board drawing areas inside your canvas
- Vector boards are independently editable and stored separately from the main document
- Useful for components, reusable elements, or isolated drawing zones
- Export canvases as PNG with scale and transparency options
- Native file save dialog - exports go directly to your filesystem
- Export workspace or page data as portable JSON files
Avnac Studio ships with a built-in Model Context Protocol server. While the app is running, any MCP client β Cursor, Claude Desktop, Windsurf, MCPJam Inspector, and more β can create, inspect, and edit designs on your canvas in real time.
Every design below was created end-to-end by an AI agent driving Avnac Studio through MCP.
| Event flyer | Packaging study | App splash |
|---|---|---|
![]() |
![]() |
![]() |
The flyer pulls photos from Unsplash; the packaging study and splash use shapes, text, and built-in stickers β all rendered by the same Saraswati engine you drive by hand.
The server is opt-in: enable it in Avnac Studio β Settings β MCP server, which binds it to 127.0.0.1 on a fixed default port (with a free-port fallback when taken) and shows the exact connect URL and bearer token (stored in your OS keyring). Copy both into your MCP client β every request must send the token as an Authorization: Bearer header.
| Transport | Endpoint | Best for |
|---|---|---|
| Streamable HTTP (recommended) | the URL shown in Settings | Cursor, Claude Code, VS Code, MCPJam |
| SSE (legacy) | the URL shown in Settings + /sse |
SSE-only clients |
Cursor β add to .cursor/mcp.json (or project .cursor/mcp.json):
{
"mcpServers": {
"avnac-studio": {
"url": "http://127.0.0.1:<port-from-settings>/",
"headers": {
"Authorization": "Bearer <token-from-settings>"
}
}
}
}Claude Code β run:
claude mcp add --transport http avnac-studio http://127.0.0.1:<port-from-settings>/ --header "Authorization: Bearer <token-from-settings>"Tip: open the connect URL in any browser (no token needed) to confirm the server is up before connecting a client.
Six reads (get_canvas_summary, get_canvas_state, get_canvas_image, list_objects, get_object_properties, get_selection), seven noun-shaped tools whose verbs are op values, and guide, the in-task router for the knowledge library:
canvasβcreate(new project: size, background, name),add-page(named draft/test page in the open project),go-page,rename-page,delete-page,clear,background,preset(IG, HD, A4β¦)elementsβrenderrects, ellipses, polygons, stars, lines, text, images and stickers in one batch (images supportfit/focalPointcrop);modify;delete;measuretext layout before drawingarrangeβalign(including opticalcap-middle),distribute,group,ungroup,fit,selectfilesβlist,open,rename(work even with no canvas open)assetsβunsplash,fonts(Google Fonts),stickersvectorβdrawscene-graph IRs of paths, shapes, constraints and mirrors as real SVG;updateby object id;read,export,delete,listguideβ route the brief to the matching workflow and rules (skill://,rules://), so the library is used during the task, not only on requestexportβpng,object
A project is a document with many pages. Agents draft, test and compare variations on a named
page in the open project (canvas op=add-page) instead of creating a separate file, and
get_canvas_summary names the active page so they always know which one they are editing. Page
switches are visible in the app immediately.
Three ready-made workflows ship as MCP prompts: design-graphic (routes the brief to the matching design-library workflow β poster, logo, create β then verifies the render), edit-canvas (diff-oriented edits on the open design), and design-audit (critique workflow + verdict). The prompt text is generated from the same embedded library the resources serve, so the two cannot drift.
With the app open, tell your agent:
Design a grand-opening flyer for a ramen shop β 1080Γ1350, bold Japanese comfort-food energy, appetizing photography.
The agent creates the canvas, pulls photography from Unsplash, renders typography and shapes, screenshots the artboard to review itself, and exports the final PNG β all through the protocol.
Full tool reference, prompt details, and client-by-client setup: docs/MCP_GUIDE.md Β· docs/MCP_TEST_PROMPTS.md.
The original Avnac web app is a browser-first editor. Avnac Studio is a ground-up desktop port of that product. Here is what changed:
- No separate backend. The web app uses an Elysia/TypeScript backend for media proxying, Unsplash, and documents. In Avnac Studio, all of that is handled inside the Go runtime - the media proxy, Unsplash integration, and file IO are part of the app binary itself.
- Native file storage. The web app stores documents in IndexedDB. Avnac Studio writes to the OS app data directory using a structured per-workspace folder layout. Files survive browser resets and profile wipes.
- One-time browser storage migration. On first run after switching to native storage, the app migrates any existing browser-local documents so nothing is lost.
- Native export dialogs. Exporting in the web app triggers a browser download. Avnac Studio opens a native OS save dialog.
- No Node or Deno process. The entire backend surface is a Go binary. There is no npm service to run, no port to remember, no server to restart.
- Lightweight. The compiled binary is small. There is no bundled Chromium (unlike Electron). The app uses the system webview.
- Frontend: React, Vite, TypeScript, Tailwind CSS, TanStack Router
- Desktop runtime: Wails v2 + Go
- Canvas/runtime engine: Saraswati (Canvas2D renderer) under
frontend/src/lib/saraswati/
Avnac Studio runs on Saraswati, a renderer-agnostic 2D scene engine.
Fabric has been sunset and removed from the active editor runtime. Saraswati now owns document structure, commands, interaction translation, and rendering intent.
Current Saraswati slice:
- strict scene graph and scene validation
- pure command reducer
- render-command pipeline
- Canvas2D renderer in the active editor path
- deterministic interaction math and bounds system
- workspace integration across files, pages, and vector boards
Important boundary:
- Saraswati state remains renderer-independent
- render backends consume commands but do not own scene truth
- UI surfaces dispatch commands instead of mutating scene objects directly
Expected impact so far:
- predictable undo/redo and state transitions through command reduction
- lower runtime coupling between editor logic and rendering implementation
- safer long-term renderer replacement because scene and command logic are separated from backend details
Formal benchmarks are not published yet, but the architecture is now in place as the primary runtime path.
Detailed design and rules live in docs/saraswati-engine.md.
If you are interested in the architecture rationale and migration details, read docs/saraswati-architecture-decisions.md.
frontend/ React UI, editor, routes, native client wrappers
avnac-system/ Go services for config, IO, workspace storage, and media proxy
app.go Wails app bootstrap and service wiring
main.go Wails runtime setup and bindings
Each file gets a dedicated folder in the OS app config directory:
<UserConfigDir>/avnac-studio/documents/<workspace-id>/
meta.json
document.json
pages.json
vector-boards.json
vector-board-docs.json
meta.jsonpowers the Files list quickly without loading full canvas datadocument.jsonstores the main Saraswati document payloadpages.jsonstores page-level workspace statevector-boards.jsonandvector-board-docs.jsonstore vector board state
- Go (compatible with this repo's
go.mod) - Node.js 22 + npm 10
- Wails CLI v2
If you use nvm, this repo includes .nvmrc, so run nvm use before installing frontend dependencies.
go install github.com/wailsapp/wails/v2/cmd/wails@latest
wails doctorcd frontend
npm ci
cd ..
wails devcd frontend
npm ci
npm run devVite runs at http://localhost:3300. Native features (file storage, export dialogs, Unsplash config) require the full Wails runtime.
- Day-to-day setup and CI/CD use
npm ci, notnpm install. npm ciinstalls exactly what is infrontend/package-lock.jsonand fails if the lockfile andfrontend/package.jsonare out of sync.- Use
npm installonly when you are intentionally adding, removing, or updating dependencies. - If dependency metadata changes, commit
frontend/package.jsonandfrontend/package-lock.jsontogether in the same commit. - If
frontend/package-lock.jsonchanged accidentally, revert it before pushing. CI and release builds rely on it being clean and deterministic.
wails buildBuild output goes to build/bin/.
Frontend:
cd frontend
npm run dev
npm run build
npm run test # all unit + feature tests
npm run test:unit
npm run test:features
npm exec tsc -- --noEmit --pretty falseGo:
go test ./...
go build ./...| Area | Path |
|---|---|
| Editor UI and behavior | frontend/src/components/ |
| Routes and navigation | frontend/src/routes/ |
| Frontend storage and document logic | frontend/src/lib/ |
| Saraswati engine and renderer migration | frontend/src/lib/saraswati/ |
| Native IO, config, and workspace services | avnac-system/ |
This desktop port is maintained by:
![]() striker561 |
![]() d3uceY |
Original Avnac web app created by @akinloluwami. Source: github.com/akinloluwami/avnac
GPL Β© 2026 striker561, d3uceY


