Skip to content

About

Avnac Studio is a cross-platform desktop design tool, a Canva alternative. Built with Go (Wails) for performance and native feel.

Resources

Contributing

Stars

78 stars

Watchers

0 watching

Forks

Latest commit

Β 

History

700 Commits

Folders and files

Repository files navigation

Avnac Studio

Avnac Studio

The native desktop version of Avnac, a design canvas for layouts, posters, social graphics, and visual documents.

striker561 d3uceY
Desktop port maintained by striker561 & d3uceY

GitHub License

Designed on the browser, openly now built for desktop.

Image

⬇️ Download

Latest Release

πŸͺŸ Windows

Download for Windows

🍎 macOS

Download for macOS - Apple Silicon

Download for macOS - Intel

🐧 Linux

Download for Linux


Upstream Notice: The main branch of this repository is a mirror of the original web app by @akinloluwami at akinloluwami/avnac. All desktop-specific work lives on the studio branch, which is the default branch of this fork.


Why the Desktop Version?

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.


What the App Can Do

Create and manage files

  • 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
image

Full canvas editor

  • 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
image

Layers, styling, and effects

  • 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
image

Multi-page workspaces

  • 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
image

Vector boards

  • 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
image

Export

  • 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
image

πŸ€– Let AI Agents Design β€” Built-in MCP Server

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
Grand Opening Ramen Flyer designed via MCP Nocturne packaging study designed via MCP Sweet Route sticker collage designed via MCP

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.

Connecting an agent

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.

What agents can do β€” 14 tools

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 β€” render rects, ellipses, polygons, stars, lines, text, images and stickers in one batch (images support fit/focalPoint crop); modify; delete; measure text layout before drawing
  • arrange β€” align (including optical cap-middle), distribute, group, ungroup, fit, select
  • files β€” list, open, rename (work even with no canvas open)
  • assets β€” unsplash, fonts (Google Fonts), stickers
  • vector β€” draw scene-graph IRs of paths, shapes, constraints and mirrors as real SVG; update by object id; read, export, delete, list
  • guide β€” route the brief to the matching workflow and rules (skill://, rules://), so the library is used during the task, not only on request
  • export β€” 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.

Try it

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.


What's Different from the Web App

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.

Tech Stack

  • Frontend: React, Vite, TypeScript, Tailwind CSS, TanStack Router
  • Desktop runtime: Wails v2 + Go
  • Canvas/runtime engine: Saraswati (Canvas2D renderer) under frontend/src/lib/saraswati/

Saraswati Engine

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.


Project Structure

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

Native Workspace Storage

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.json powers the Files list quickly without loading full canvas data
  • document.json stores the main Saraswati document payload
  • pages.json stores page-level workspace state
  • vector-boards.json and vector-board-docs.json store vector board state

Development

Prerequisites

  • 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 doctor

Desktop App (Recommended)

cd frontend
npm ci
cd ..
wails dev

Frontend Only (UI work)

cd frontend
npm ci
npm run dev

Vite runs at http://localhost:3300. Native features (file storage, export dialogs, Unsplash config) require the full Wails runtime.

Contributor Note: Dependency Installs

  • Day-to-day setup and CI/CD use npm ci, not npm install.
  • npm ci installs exactly what is in frontend/package-lock.json and fails if the lockfile and frontend/package.json are out of sync.
  • Use npm install only when you are intentionally adding, removing, or updating dependencies.
  • If dependency metadata changes, commit frontend/package.json and frontend/package-lock.json together in the same commit.
  • If frontend/package-lock.json changed accidentally, revert it before pushing. CI and release builds rely on it being clean and deterministic.

Production Build

wails build

Build output goes to build/bin/.


Useful Commands

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 false

Go:

go test ./...
go build ./...

Where To Work

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/

Port Maintainers

This desktop port is maintained by:

striker561
striker561
d3uceY
d3uceY

Credits

Original Avnac web app created by @akinloluwami. Source: github.com/akinloluwami/avnac


License

GPL Β© 2026 striker561, d3uceY

About

Avnac Studio is a cross-platform desktop design tool, a Canva alternative. Built with Go (Wails) for performance and native feel.

Resources

Contributing

Stars

78 stars

Watchers

0 watching

Forks

Releases

Contributors

Languages