https://github.com/madebysan/greenlight-legacy
Create film vision decks from screenplays in minutes. Next.js + Claude API + FLUX image generation.
https://github.com/madebysan/greenlight-legacy
ai claude-api filmmaking flux nextjs pre-production screenwriting
Last synced: 12 days ago
JSON representation
Create film vision decks from screenplays in minutes. Next.js + Claude API + FLUX image generation.
- Host: GitHub
- URL: https://github.com/madebysan/greenlight-legacy
- Owner: madebysan
- License: other
- Created: 2026-04-22T23:17:17.000Z (3 months ago)
- Default Branch: main
- Last Pushed: 2026-05-15T21:45:56.000Z (2 months ago)
- Last Synced: 2026-06-21T14:57:06.819Z (about 1 month ago)
- Topics: ai, claude-api, filmmaking, flux, nextjs, pre-production, screenwriting
- Language: TypeScript
- Homepage:
- Size: 50.5 MB
- Stars: 1
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
Awesome Lists containing this project
README
Greenlight
Script to vision deck in about ten minutes.
For the space between finishing a script and figuring out what the film actually looks like.
Next.js React 19 Tailwind CSS 4 Selected text providers FLUX + Gesture Draw LoRA
https://github.com/user-attachments/assets/e5fbef69-2bd7-43b3-858a-e4ef32b0c419
I have friends in the film industry who spend days, sometimes weeks, on the same manual work: turning a script into a deck they can show investors, pitch to potential collaborators, or use to make the film feel real before there's a crew. As a designer, I've designed a lot of decks for documentary films, so I have a feel for what the output usually looks like. Greenlight is me trying to reverse-engineer that output from a single source, a movie script.
The way it works is pretty simple: you share your script and you get a vision deck with a lot of ideas and assumptions based on the script for you to use as a starting point. Things like logline, tone, scene map, characters, poster directions, a palette, the overall feel of the thing. Something to show a DP, a producer, or a friend whose opinion matters, before there's a crew or a budget.
It's best for students, first-time filmmakers, or anyone who struggles with moving from scripts into decks. It's not the right tool for teams already committed to production with a crew and a schedule. There are way better tools for that like StudioBinder and Movie Magic that offer solutions and a level of granularity that is not here. Greenlight is for day one.
## What's in a generated deck
| Tab | What's in it |
|---|---|
| **Overview** | Logline, taglines, synopsis, film identity, themes, scope at a glance |
| **Mood & Tone** | Atmosphere, tonal descriptors, color palette, music and sound direction, soundtrack references (with TMDB posters), similar moods |
| **Scenes** | Scene-by-scene map with inline storyboard frames. Sequence or location grouping. |
| **Locations** | Unique locations grouped with scenes, time variations, and set requirements |
| **Cast & Crew** | Characters with AI portraits plus production insights based on script complexity |
| **Production Design** | Cross-referenced props and wardrobe with reference sketches |
| **Title & Palette** | Color palette and title treatment with the full Google Fonts catalog |
| **Poster Concepts** | Visual directions across categories. Conversation starters, not final art. |
## How to use it
You'll need structured screenplay JSON to start. I use [Gemini Pro](https://gemini.google.com/app) for this: upload your script, paste the extraction prompt that Greenlight provides, Gemini hands back JSON that matches Greenlight's schema.
Paste that JSON into Greenlight. On first use the app asks for your selected text provider API key and (optionally) your fal.ai and TMDB keys. They're stored in your browser's `localStorage` and sent to Greenlight's Vercel functions only when the app needs to call the selected provider. Greenlight does not intentionally save those keys server-side.
The deck generates automatically. Your selected text provider does the writing, fal.ai generates the images. Both run in parallel, so most of a deck is ready in a couple minutes. You can edit, regenerate, or swap out sections as you go.
The report-writing pass first reads the script's genre, tone, period, locations, themes, and props, then adapts the deck language to that lane. A quiet romance should not get the same poster concepts or mood references as a siege horror film, a period court comedy, or a science-fiction epic.
PDF upload is wired in the backend but disabled in the UI. Serverless function timeouts made it unreliable for feature-length scripts, so paste-JSON is the working path today.
## Images
All images (storyboards, character portraits, props, posters) run through FLUX dev plus the [Gesture Draw LoRA](https://huggingface.co/glif/Gesture-Draw) on fal.ai. The LoRA gives everything a consistent black-ink-on-white-paper sketch style, so every asset looks like it came from the same storyboard artist's hand. Use **Generate all images** in the More menu to batch everything in one click.
Cost is roughly $0.035 per image on fal.ai (April 2026).
## Running locally
```bash
git clone https://github.com/madebysan/greenlight.git
cd greenlight
npm install
npm run dev
```
Open [http://localhost:3000](http://localhost:3000). The app is a standalone Next.js project, no separate backend required. Serverless functions live in `app/api/` as Next.js route handlers.
### Dependencies
All listed in `package.json`. The important ones:
- `next@16`, `react@19`, `tailwindcss@4` (Next.js App Router stack)
- `@anthropic-ai/sdk` (Claude client)
- `@fal-ai/client` (fal.ai client for image generation)
- `radix-ui`, `lucide-react`, `class-variance-authority` (shadcn/ui foundations)
Node 20+ recommended.
### API keys
Every API call is keyed by the end user. On first use the app pops a modal that stores your keys in `localStorage`. When you generate a deck, the relevant key and screenplay data are sent to Greenlight's Vercel functions so they can call Claude, OpenAI, DeepSeek, Gemini, fal.ai, or TMDB. The server does not intentionally store those keys.
| Key | Purpose | Required? | Get one at |
|-----|---------|-----------|-----------|
| Text provider API key | Document generation (Overview, Mood & Tone, Scenes, Storyboards, Poster Concepts) | **Required** | Claude, OpenAI-compatible, DeepSeek, or Gemini provider console |
| fal.ai API key | Image generation (storyboards, portraits, props, posters) | Optional (text-only deck without it) | [fal.ai/dashboard](https://fal.ai/dashboard/keys) |
| TMDB API key | Poster thumbnails on Mood & Tone (Similar Moods, Soundtrack References) | Optional (tab works without it, just without poster thumbs) | [themoviedb.org/settings/api](https://www.themoviedb.org/settings/api) |
For local development you can skip the in-app modal by adding the same variables to `.env.local`:
```
ANTHROPIC_API_KEY=sk-ant-...
FAL_KEY=...
TMDB_API_KEY=...
```
These server-side env vars are used as a fallback when a user hasn't entered a key in the modal. On the public deployment no server-side keys are set, so every visitor brings their own.
## Tech stack
- **Framework:** Next.js 16, React 19, Tailwind CSS 4, shadcn/ui
- **AI:** Claude, OpenAI-compatible, DeepSeek, or Gemini for text; FLUX dev plus Gesture Draw LoRA (fal.ai) for images
- **Data:** TMDB REST API for film reference lookups
- **Fonts:** Space Grotesk and Space Mono (UI), full Google Fonts catalog for title treatment
- **Theme:** Dark default with light mode toggle
## License
[All rights reserved](LICENSE)
---
Made by [santiagoalonso.com](https://santiagoalonso.com)