# Eikon Studio by Mohtasham Murshid Madani

[Canonical page](https://www.mohtasham.dev/work/eikon-studio)

An open-source image platform I built because the existing options were expensive, awkward, or would not accept my own provider keys.

Eikon turns Google and OpenAI image models into one self-hostable studio and API. Generations keep running through Convex after the browser closes, then return to history, the gallery, and usage analytics.

Role: Creator. Updated 2026-08-26.

I started Eikon because I hated the existing image-generation platforms. Some were too expensive. Others had terrible interfaces. Most would not let me use my own provider keys.

The first version only supported Nano Banana. At the time, it was the only image model I actually liked using. I started with Vercel's Nano Banana Starter template, which was little more than a simple generation screen. Most of Eikon has been built beyond that starting point.

## My work

- Built alone
- Product design
- Full-stack development

## Current status

- Open source
- Self-hostable
- Actively developed

## Ready models

- Nano Banana 2
- Nano Banana Pro
- GPT Image 2

## Why bring your own key

I do not want to resell generations or add another markup. People already have access to Google and OpenAI. Eikon should make those models easier to use, not become another company selling the same inference through a different screen.

A creator can use the studio without learning a provider API. A developer can send the same request through Eikon's REST API. AI agents will eventually use the CLI and SDK without touching the dashboard. The web interface and REST API work today. The CLI and TypeScript and Python SDKs are still in development.

## The hardest part was making generations persist

An image generation should not belong to an open browser tab. A user might change pages, close the app, or return later while the provider is still working. Eikon creates the generation record in Convex before starting the provider request. Convex keeps the work running, saves the completed output, and updates the user's history.

Building this was the hardest part of the project. Provider calls can take time, fail halfway through, or finish after the user has left. The system has to know whether it is safe to retry without accidentally creating another paid generation.

## What works now and where I want to take it

The current release handles text-to-image generation, image editing, references, reusable prompt skills, folders, history, a personal gallery, usage analytics, Google sign-in, provider credentials, platform API keys, and a public REST endpoint. A couple of my friends and colleagues use it. Anyone can run the hosted version or self-host the project.

The useful breadth of fal.ai is the long-term reference point, not its branding or payment model. I want Eikon to provide a visual studio and one consistent way to call image and video models. More provider adapters, runnable models, comparison tools, model playgrounds, a CLI, and typed SDKs are still ahead.

## A generation can outlive the browser

1. Connect a key: Save a Google or OpenAI credential.

2. Choose a model: Select one of the three ready image models.

3. Add the input: Write a prompt or attach reference images.

4. Start the job: Convex records the generation before provider work begins.

5. Leave if needed: Navigation or closing the app does not cancel the work.

6. Return later: The result appears in generation history when it finishes.

7. Keep the image: Download it or organize it in the gallery.

## How Eikon connects the interface to the provider

Ways in: Web studio: Available now; REST API: Available now; CLI and SDKs: In development

Eikon: Model registry: Capabilities and readiness; Generation contract: One request shape and job lifecycle; Credential boundary: Server-side provider-key access

Providers: Google: Nano Banana models; OpenAI: GPT Image

Convex: Background work: Continues after the browser leaves; Database and storage: Keeps the record and returned media

Back to the user: History: Status and past generations; Gallery: Folders, saved media, and downloads; Analytics: Usage and estimated cost

## what the user does to what Eikon keeps

- connect provider key: Encrypted credential. Only server-side code can resolve it

- choose a model: Ready catalog entry. Unavailable models stay out of the selector

- prompt + references: Validated request. Saved before provider work starts

- start generation: Persistent Convex record. Work continues after navigation or close

- provider returns media: Stored output. Copied into Convex storage

- generation completes: History and analytics. The result returns to the account

## Public REST API

```text
{
  "prompt": "An isometric keyboard switch cutaway",
  "provider": "openai",
  "imageSize": "2K",
  "aspectRatio": "landscape"
}
```

curl -X POST https://eikonstudio.xyz/api/v1/generate -H 'Authorization: Bearer eik_...'

The current REST API sends a generation through the same account-scoped path as the studio.

I built Eikon because using an image model should not require choosing between a bad interface and another expensive subscription.

- [Open Eikon Studio ↗](https://eikonstudio.xyz)
- [View the source ↗](https://github.com/MohtashamMurshid/eikonstudio)

[Visit Eikon Studio](https://eikonstudio.xyz)