# make-comics: a Next.js app that generates comic books with image and text models

> make-comics is a Next.js 16 application that turns a prompt into a comic: Google Flash Image 2.5 draws the panels, Qwen3 80B writes the titles and narrative, and the app keeps characters visually consistent across panels by referencing previous pages and uploaded character images. The repository is a complete, deployable web app with Clerk auth, Neon Postgres, S3 storage and Upstash rate limiting, not a library.

**Nutlope/make-comics** — Create full comics with AI in seconds

- Repository: https://github.com/Nutlope/make-comics
- Website: https://www.makecomics.io/
- Stars: 520 · Forks: 104
- Language: TypeScript
- License: not declared
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/nutlope-make-comics

## Two models, one prompt, a whole comic

Make Comics is a Next.js application for creating comic books with AI, generating stories, characters and panels. The project description is short, Create comic books with AI, and the homepage is makecomics.io.

The mechanism is a split between two models hosted by Together AI. Google Flash Image 2.5 generates the comic pages, and Qwen3 80B generates story titles and narratives. The README also states the two techniques that make the output coherent across pages: the AI references previous pages for visual coherence, and it uses uploaded character images to maintain consistency across panels.

That second point is the part worth understanding. Generating a comic is not one image, it is a sequence of images that has to look like it depicts the same character four times. A model asked for a panel in isolation will draw a different person every time. The approach here is to give the model the character as an uploaded image and to feed the previous pages back in as context, which is a prompting and context-assembly strategy rather than a fine-tuned model.

The audience is a developer building a comic or storyboard generator, and the app is presented as a working product with a public site, not as a research artefact. The primary language is TypeScript, the default branch is main, and the last push was on 2026-07-30.

One detail in the manifest is worth noting for anyone assessing the code quality: the package is named my-v0-project at version 0.1.0 and marked private. This is a scaffolded project that was published under a different name, which is a fair signal about how much polish to expect from the packaging.

## The stack, and why every piece is there

The tech stack list in the README is short and every entry has an obvious job.

Next.js 16 with React 19 and Tailwind CSS is the application shell. Drizzle ORM with a Neon PostgreSQL database is the persistence layer, and the presence of a drizzle/ directory and a drizzle.config.ts at the root confirms the ORM is wired in rather than aspirational. Clerk handles authentication, which is the piece that makes the app multi-user rather than a local tool. AWS S3 stores the generated images, Upstash Redis does rate limiting, and jsPDF produces the final PDF.

The Together AI entry is the one that matters for the product, because it is the point where the money goes. Flash Image 2.5 is the panel generator and Qwen3 80B is the writer, and the model links in the README point at Together AI's model pages for both, so the pricing and the rate limits of that provider are part of your cost model from day one.

The dependency list confirms the same architecture in more detail. The AWS SDK client is there for S3, @neondatabase/serverless for the database, @clerk/nextjs for auth, @upstash/redis and @upstash/ratelimit for the rate limiting, and a long tail of Radix UI primitives for the component layer, with cmdk and class-variance-authority and tailwind-merge for the styling conventions.

The scripts block is the standard Next.js set with one addition:

```json
  "scripts": {
    "build": "next build",
    "dev": "next dev",
    "lint": "eslint .",
    "start": "next start",
    "test": "node --test lib/*.test.cts"
  },
```

The test script uses the Node built-in test runner against files in lib/, so the tests are plain Node rather than a framework, which keeps the dependency list shorter.

## Cloning it and supplying the keys it expects

The README's setup section is three steps. Clone the repo with `git clone https://github.com/nutlope/make-comics`. Then create a `.env` file based on `.example.env` and add your API keys. Then run `npm install` and `npm run dev` to install dependencies and run locally.

The keys are the substance of that second step, and the file is named .example.env at the root of the repository, so you copy it rather than write it from scratch. The variables it expects are grouped by service. For Together AI there is `TOGETHER_API_KEY=<your_together_ai_api_key>`. For AWS S3 there are `S3_UPLOAD_KEY`, `S3_UPLOAD_SECRET`, `S3_UPLOAD_BUCKET` and `S3_UPLOAD_REGION`. For the database there is `DATABASE_URL=<your_database_url>`, with the README pointing at Neon to set up the PostgreSQL database. For Clerk there are `NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY` and `CLERK_SECRET_KEY`. For Upstash Redis there are `UPSTASH_REDIS_REST_URL` and `UPSTASH_REDIS_REST_TOKEN`.

Notice that the Clerk publishable key is prefixed NEXT_PUBLIC_, which means it is compiled into the client bundle and is not a secret, while the Clerk secret key and the S3 secret are server-side. The envConfig.ts file at the root of the repository is where that split is presumably enforced, and envConfig.ts together with the .example.env file is the first thing to read if the app fails to start after you have filled in the values.

Two details in the variable names hint at how the S3 integration is scoped. The names are S3_UPLOAD_KEY and S3_UPLOAD_SECRET rather than AWS_ACCESS_KEY_ID, so the app is configured for a specific upload bucket rather than picking up an ambient AWS environment. And the repository has a pnpm-lock.yaml and a pnpm-workspace.yaml, so pnpm is the intended package manager even though the README says npm install.

## The repository layout and what it says about scope

The top-level listing describes a standard modern Next.js application with a few specifics worth noting.

There is an app/ directory, which in Next.js App Router convention holds the routes, and a components/ directory with a components.json file beside it, the shadcn/ui configuration that declares the component conventions the project follows. There are hooks/ and lib/ directories, and the lib/ directory is where the Node test files referenced by the test script live.

The infrastructure bits are visible too. drizzle/ holds the schema and migrations, drizzle.config.ts points at the database, and proxy.ts sits at the root, which in the Next.js ecosystem is where request-level routing or middleware behaviour goes. There is a public/ directory for static assets, styles/ and postcss.config.mjs for the Tailwind pipeline, next.config.mjs for the framework configuration, and envConfig.ts for the environment handling.

The AGENTS.md file at the root is worth flagging. It means the repository ships instructions for AI coding agents, which is a growing convention and a reasonable one for a project where a contributor might otherwise waste a cycle rediscovering the conventions in components.json.

What is not here is as informative as what is. There is no tests/ directory, no CI workflow configuration in the listing, and no Dockerfile. The test script points at lib/*.test.cts, so unit tests exist alongside the library code, but the repository as published has no separate integration test suite and no container recipe.

For an evaluation, the practical question is whether you want the model orchestration logic, which is the interesting part, or the whole product, which includes the auth, storage, rate limiting and billing surface that comes with it.

## Where this project does not go, and who it is not for

Three limits, and they are structural rather than gaps that a contributor could close.

The first is that this is a product, not a component. There is no published package, no exported function, and nothing in the tree that is designed to be imported by another project. The name my-v0-project in the manifest and the private flag make that plain. If you want to add comic generation to an existing application, you are going to read the model-calling code and write your own integration, with your own auth, your own storage and your own rate limiting, and the parts you can copy are the prompt assembly and the context handling.

The second is the cost model. Two hosted models, image storage, a serverless Postgres, authentication and Redis rate limiting is six services before you generate a single panel, and the image model is the one that dominates the bill. A team evaluating this should model the per-comic cost with real panel counts rather than assuming the free tier covers it.

The third is the consistency mechanism itself. The README is honest that consistency comes from referencing previous pages and from uploaded character images, which is a best-effort approach rather than a character model. Nothing in the repository trains a consistent character, and nothing in it constrains the license or the training provenance of the underlying models, which is worth checking with Together AI directly for a commercial deployment.

One more practical point: the README does not document how the generated comics are attributed, whether the model providers require credit for output generated with their models, or what the commercial terms are for the Flash Image 2.5 and Qwen3 80B models at volume. That is the first question to answer before building on this, and the answer is not in the repository.

## Conclusion

Adopt make-comics if you are building a comic generation product and want a working reference implementation of image plus text model orchestration with character consistency, rather than a starting point from scratch. Do not adopt it as a library, since nothing here is packaged for reuse, and do not expect model output quality to be solved by the app, since the consistency mechanism is prompt and reference based. Verify first that the Together AI models named in the README are still the ones you want, that the S3, Neon, Clerk and Upstash accounts you create are yours to use for generated content, and that the character image upload path handles likeness rights on your side.

## FAQ

### What models does make-comics use?

It uses Google Flash Image 2.5 to generate the comic pages and Qwen3 80B to generate the story titles and narratives, both hosted on Together AI. The AI references previous pages for visual coherence and uses uploaded character images to maintain consistency across panels.

### How do I run make-comics locally?

Clone the repository with git clone https://github.com/nutlope/make-comics, create a .env file based on .example.env with your API keys, then run npm install and npm run dev. The env file needs a Together AI key, S3 upload credentials, a Neon DATABASE_URL, Clerk keys and Upstash Redis credentials.

### What services does make-comics depend on?

Next.js 16 with React 19 and Tailwind CSS for the app, Drizzle ORM with a Neon PostgreSQL database for storage, Clerk for authentication, Together AI for the LLM and image models, AWS S3 for image storage, Upstash Redis for rate limiting, and jsPDF for PDF generation.

### How does make-comics keep a character looking the same across panels?

Through two mechanisms the README describes: the AI references previous pages for visual coherence, and it uses uploaded character images to maintain consistency across panels. Both are context and prompting approaches rather than a trained character model.

### Can I use make-comics as a library in another project?

Not directly. The package is named my-v0-project, is marked private at version 0.1.0, and the repository publishes no releases, so the model orchestration code is there to read and adapt rather than to install. The README's contribution note is that contributions and pull requests are welcome.

## Sources

- [Issues](https://github.com/Nutlope/make-comics/issues)
- [Nutlope/make-comics on GitHub](https://github.com/Nutlope/make-comics)
- [Project website](https://www.makecomics.io/)
- [README](https://github.com/Nutlope/make-comics/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/nutlope-make-comics