DEV Community: local ai

【2026】Générer automatiquement des figures scientifiques avec l’IA – Fini Illustrator

local ai — Wed, 01 Apr 2026 14:03:49 +0000

Introduction

Pour les chercheurs qui rédigent des articles scientifiques, la création de figures (Figures) est l'une des tâches les plus chronophages.

Créer un Graphical Abstract a pris une demi-journée
Le reviewer demande : « Veuillez refaire la Figure 3 » – c'est le désespoir
Pas le temps d'apprendre Illustrator ou BioRender

Cela vous parle ?

Grâce aux progrès de l'IA générative, il est désormais possible de générer automatiquement des figures scientifiques de qualité publication, simplement à partir d'instructions textuelles. Dans cet article, je présente le fonctionnement et un workflow concret.

Les limites des outils traditionnels

Outil	Avantages	Inconvénients
Adobe Illustrator	Grande liberté créative	Courbe d'apprentissage élevée, abonnement mensuel
BioRender	Nombreux modèles	À partir de 39 $/mois, personnalisation limitée
PowerPoint	Simple d'utilisation	Qualité insuffisante pour une publication
matplotlib / R	Reproductible par code	Design peu esthétique, long à réaliser

Tous ces outils exigent soit des compétences en design, soit beaucoup de temps – souvent les deux.

Comment fonctionne la génération de figures par IA

L'architecture de base est la suivante :

Entrée utilisateur (texte / données)
        ↓
  LLM (conception du layout · décomposition des éléments)
        ↓
  Modèle de génération d'images (rendu)
        ↓
  Post-traitement (ajustement du style · placement des labels)
        ↓
  Sortie (PNG / SVG / PDF)

Le point clé est un pipeline en deux étapes : le LLM comprend d'abord la « structure » de la figure, puis le modèle de génération d'images se charge du « dessin ». Cela permet de maintenir la précision scientifique tout en produisant un design soigné.

En pratique : créer des figures scientifiques avec l'IA

Méthode 1 : Génération manuelle par prompt engineering

Donner des instructions directement à un LLM multimodal comme GPT-4o ou Claude :

Veuillez créer un Graphical Abstract avec le contenu suivant :
- Sujet de recherche : Prédiction de structure protéique par deep learning
- Gauche : Données d'entrée (séquence d'acides aminés)
- Centre : Traitement par réseau neuronal
- Droite : Sortie (structure 3D)
- Style : Design épuré façon Cell / Nature

Problème : Il faut ajuster finement le prompt à chaque fois, et la qualité est irrégulière. De plus, spécifier à chaque fois les formats adaptés à la publication (résolution, police, palette de couleurs) est fastidieux.

Méthode 2 : Utiliser un outil IA spécialisé

Un outil IA dédié aux figures scientifiques résout ces problèmes. SciDraw AI est un service IA optimisé pour la création de figures d'articles scientifiques.

Caractéristiques principales :

📝 Qualité publication à partir de simples instructions textuelles
🎨 Graphical Abstracts, diagrammes de flux expérimentaux, schémas conceptuels, visualisation de données
📐 Application automatique des standards de publication (≥300 dpi, tailles de police adaptées)
🔄 Modifications et ajustements possibles après génération
📥 Export en PNG, SVG ou PDF

Utilisation simple :

Accédez à sci-draw.com
Décrivez la figure souhaitée en texte (le français fonctionne)
L'IA génère la figure
Ajoutez des instructions de modification si nécessaire
Téléchargez la figure finalisée

Cas d'utilisation

1. Graphical Abstract

Lors de la soumission à une revue, un Graphical Abstract résumant la recherche en une seule image est souvent exigé. Avec SciDraw AI, il suffit de saisir le résumé de l'article pour générer un Graphical Abstract avec une mise en page adaptée.

2. Diagramme de workflow expérimental

Exemple : « Veuillez créer un diagramme de la procédure expérimentale
de clonage génique par PCR.
Étapes : Extraction d'ADN → Conception des amorces → Amplification PCR → 
Électrophorèse sur gel → Ligation → Transformation »

3. Schémas conceptuels et diagrammes de mécanismes

Les mécanismes biologiques complexes ou les schémas de systèmes d'ingénierie peuvent également être générés à partir d'une description textuelle.

Points d'attention pour l'utilisation de figures IA dans les publications

Lors de l'utilisation de figures générées par IA dans un article scientifique, veuillez noter les points suivants :

1. Vérifier la politique de la revue

Politiques d'utilisation de l'IA des principales revues :

Nature : Utilisation autorisée si mentionnée dans les Methods (pas de crédit d'auteur pour l'IA)
Science : Divulgation également requise
IEEE : Recommande de divulguer l'utilisation d'outils assistés par IA

2. Vérifier la précision scientifique

Les figures générées par IA doivent toujours être vérifiées par le chercheur lui-même. La précision des formules structurelles et des données numériques relève de la responsabilité humaine.

3. Droits d'auteur et originalité

Les figures générées par IA sont généralement considérées comme du contenu original, mais veuillez respecter les directives de la revue concernée.

Résumé

Aspect	Méthode traditionnelle	Génération par IA
Temps de création	Heures à jours	Minutes
Compétences en design	Nécessaires	Non requises
Cohérence de qualité	Variable selon la personne	Stable
Facilité de correction	Travail manuel	Correction instantanée par instruction textuelle
Coût	Illustrator à partir de 22 $/mois / BioRender à partir de 39 $/mois	Crédits gratuits disponibles

Le temps des chercheurs devrait être consacré à la recherche elle-même – pas au design de figures. Utilisez les outils IA pour optimiser votre workflow de publication.

Liens utiles

【2026】Wissenschaftliche Abbildungen mit KI automatisch erstellen – Illustrator war gestern

local ai — Tue, 31 Mar 2026 14:53:17 +0000

Einleitung

Für Forschende, die wissenschaftliche Paper schreiben, ist die Erstellung von Abbildungen (Figures) eine der zeitaufwendigsten Aufgaben.

Ein Graphical Abstract hat einen halben Tag gedauert
Der Reviewer schreibt: „Bitte erstellen Sie Figure 3 neu" – Verzweiflung
Keine Zeit, Illustrator oder BioRender zu lernen

Kommt Ihnen das bekannt vor?

Dank der rasanten Entwicklung generativer KI ist es inzwischen möglich, allein durch Textanweisungen wissenschaftliche Abbildungen auf Publikationsniveau automatisch zu generieren. In diesem Artikel stelle ich die Funktionsweise und einen konkreten Workflow vor.

Grenzen herkömmlicher Tools

Tool	Vorteile	Nachteile
Adobe Illustrator	Hohe Gestaltungsfreiheit	Steile Lernkurve, monatliche Kosten
BioRender	Viele Vorlagen	Ab $39/Monat, eingeschränkte Anpassung
PowerPoint	Einfach zu bedienen	Nicht ausreichend für Publikationsqualität
matplotlib / R	Reproduzierbar per Code	Geringes Designniveau, zeitaufwendig

Alle diese Tools erfordern entweder Designkenntnisse oder viel Zeit – oft beides.

So funktioniert KI-basierte Abbildungserstellung

Die grundlegende Architektur sieht folgendermaßen aus:

Benutzereingabe (Text / Daten)
        ↓
  LLM (Layout-Planung · Elementzerlegung)
        ↓
  Bildgenerierungsmodell (Rendering)
        ↓
  Nachbearbeitung (Stilanpassung · Beschriftung)
        ↓
  Ausgabe (PNG / SVG / PDF)

Der Schlüssel ist eine zweistufige Pipeline: Das LLM versteht zunächst die „Struktur" der Abbildung, dann übernimmt das Bildgenerierungsmodell das „Zeichnen". So bleibt die wissenschaftliche Genauigkeit erhalten, während ein ansprechendes Design entsteht.

Praxis: Wissenschaftliche Abbildungen mit KI erstellen

Methode 1: Manuell per Prompt Engineering

Direkte Anweisung an multimodale LLMs wie GPT-4o oder Claude:

Bitte erstellen Sie ein Graphical Abstract mit folgendem Inhalt:
- Forschungsthema: Deep Learning für Proteinstrukturvorhersage
- Links: Eingabedaten (Aminosäuresequenz)
- Mitte: Neuronales Netzwerk
- Rechts: Ausgabe (3D-Struktur)
- Stil: Sauberes Design im Stil von Cell / Nature

Problem: Der Prompt muss jedes Mal feinabgestimmt werden, und die Qualität ist inkonsistent. Außerdem ist es mühsam, jedes Mal publikationsgerechte Formate (Auflösung, Schriftart, Farbschema) anzugeben.

Methode 2: Spezialisierte KI-Tools nutzen

Mit einem KI-Tool, das auf wissenschaftliche Abbildungen spezialisiert ist, lassen sich diese Probleme lösen. SciDraw AI ist ein KI-Service, der für die Erstellung wissenschaftlicher Abbildungen optimiert wurde.

Hauptmerkmale:

📝 Publikationsqualität allein durch Textanweisungen
🎨 Graphical Abstracts, Experiment-Flowcharts, Konzeptdiagramme, Datenvisualisierung
📐 Automatische Einhaltung von Publikationsstandards (≥300 dpi, passende Schriftgrößen)
🔄 Nachträgliche Korrekturen und Feinanpassungen möglich
📥 Export als PNG, SVG oder PDF

So einfach geht's:

sci-draw.com aufrufen
Gewünschte Abbildung als Text beschreiben (Deutsch funktioniert)
Die KI generiert die Abbildung
Bei Bedarf Änderungsanweisungen ergänzen
Fertige Abbildung herunterladen

Anwendungsbeispiele

1. Graphical Abstract

Bei der Einreichung in Fachzeitschriften wird oft ein Graphical Abstract verlangt, das den Forschungsinhalt in einer Abbildung zusammenfasst. Mit SciDraw AI genügt die Eingabe des Abstracts, um ein passendes Layout zu generieren.

2. Experiment-Workflow-Diagramm

Beispiel: „Bitte erstellen Sie ein Diagramm des Versuchsablaufs
für Genklonierung mittels PCR.
Schritte: DNA-Extraktion → Primer-Design → PCR-Amplifikation → 
Gelelektrophorese → Ligation → Transformation"

3. Konzept- und Mechanismusdiagramme

Auch komplexe biologische Mechanismen oder technische Systemkonzepte können per Textbeschreibung generiert werden.

Hinweise zur Nutzung von KI-Abbildungen in Publikationen

Bei der Verwendung KI-generierter Abbildungen in wissenschaftlichen Arbeiten ist Folgendes zu beachten:

1. Journal-Richtlinien prüfen

KI-Nutzungsrichtlinien wichtiger Zeitschriften:

Nature: Nutzung erlaubt, wenn in den Methods angegeben (keine Autorenschaft für KI)
Science: Offenlegung ebenfalls erforderlich
IEEE: Empfiehlt die Offenlegung von KI-gestützten Tools

2. Wissenschaftliche Genauigkeit prüfen

KI-generierte Abbildungen müssen immer von den Forschenden selbst auf inhaltliche Richtigkeit geprüft werden. Die Korrektheit von Strukturformeln und Zahlenwerten liegt in menschlicher Verantwortung.

3. Urheberrecht und Originalität

KI-generierte Abbildungen gelten grundsätzlich als Originalinhalte, aber bitte beachten Sie die jeweiligen Zeitschriftenrichtlinien.

Zusammenfassung

Aspekt	Herkömmlich	KI-Generierung
Erstellungszeit	Stunden bis Tage	Minuten
Designkenntnisse	Erforderlich	Nicht nötig
Qualitätskonsistenz	Personenabhängig	Stabil
Korrekturaufwand	Manuell	Per Textanweisung sofort
Kosten	Illustrator ab $22/Mon. / BioRender ab $39/Mon.	Kostenlose Credits verfügbar

Die Zeit von Forschenden sollte für die Forschung selbst genutzt werden – nicht für das Designen von Abbildungen. Nutzen Sie KI-Tools, um Ihren Publikations-Workflow zu optimieren.

Weiterführende Links

I Spent Two Hours Rotoscoping a Dance Video. Then an AI Did It in Two Minutes.

local ai — Sun, 29 Mar 2026 04:52:08 +0000

I Spent Two Hours Rotoscoping a Dance Video. Then an AI Did It in Two Minutes.

Last Wednesday night, I had a simple task: extract a dancer from a video and put her on a clean background.

Simple, right?

I opened Premiere Pro. Fired up the Roto Brush. Two hours later, the hair was a smeared mess, the skirt edges looked like they'd been cut with safety scissors, and I was questioning my career choices.

Then I tried an online matting tool. Uploaded the video, waited five minutes, and got back something that flickered like a strobe light — the extraction boundary jittered on every single frame.

At 1 AM, frustrated and caffeinated, I stumbled on a GitHub repo called MatAnyone2.

Two minutes later, I had my jaw on the floor.

What Is MatAnyone2?

MatAnyone2 is a video matting framework developed by researchers at S-Lab (Nanyang Technological University) and SenseTime Research. It was just accepted to CVPR 2026 — the top conference in computer vision.

What it does: takes a regular video — no green screen, no special lighting — and extracts people with pixel-perfect alpha mattes. That means hair strands, translucent fabrics, wispy edges — all preserved with precise transparency values.

This isn't binary segmentation (person = 1, background = 0). This is real matting. Every pixel gets a transparency value between 0 and 1. The difference matters enormously when you composite onto a new background.

How It Works (The Interesting Part)

The core innovation is something called the Matting Quality Evaluator (MQE) — essentially, the model has its own built-in quality inspector.

Here's the problem it solves: traditional matting models train on synthetic data. You take a foreground, paste it on a background, and the model learns to undo that composition. But synthetic data is too clean. Real-world videos have wind-blown hair, changing lighting, motion blur, complex occlusions. Models trained purely on synthetic data choke on these.

MatAnyone2's approach is clever. The MQE generates a pixel-level quality map for each matte — marking which regions are reliable and which are garbage. During training, the model only learns from the reliable pixels. Bad predictions get suppressed instead of reinforcing mistakes.

Using this mechanism, the team built VMReal: a dataset of 28,000 real-world video clips and 2.4 million frames, each annotated with quality evaluation maps. That's why it works so well on real footage — it was trained on real footage.

My First Run

The workflow is dead simple:

Upload your video
Click a few points on the first frame to mark your subject (SAM handles the mask generation)
Hit "Video Matting"

On my RTX 3080, that dance video processed in about two minutes.

I opened the alpha channel output and just stared at it. Individual hair strands. The gap between fingers. The semi-transparent edge of a flowing skirt. All clean. All temporally consistent — no flickering between frames.

Those two hours I spent with Roto Brush suddenly felt very personal.

Real Results

Here are some test samples to give you a feel for the extraction quality:

Look at the hair boundaries. Look at the semi-transparent regions. This isn't a hard cutout — it's a proper alpha matte with continuous transparency values. When you composite these onto a new background, there's no "sticker effect."

Multi-Person Support

You can mark multiple people in the same video and extract them separately. For anyone doing VFX compositing, this is a game-changer.

The Data Pipeline

What I find particularly elegant is how the MQE doubles as a data curator. Multiple matting models process the same video. The MQE evaluates each result, picks the best regions from each, and stitches them into a higher-quality composite annotation.

This means annotation quality improves as more models and data are added. It's not a static tool — it's a system that gets better over time.

Getting Started

Hardware Requirements

NVIDIA GPU (8GB+ VRAM recommended)
CUDA support

Command Line (Fastest)

python inference_matanyone2.py -i your_video.mp4 -m your_mask.png -o results/

Feed it a video and a first-frame mask. Out comes a foreground video (green screen composite) and an alpha matte video.

Interactive GUI (Recommended for First-Timers)

Launch the Gradio interface and everything is point-and-click. SAM is built in, so you don't need to prepare masks in advance.

Python API (For Integration)

from matanyone2 import MatAnyone2, InferenceCore

model = MatAnyone2.from_pretrained("PeiqingYang/MatAnyone2")
processor = InferenceCore(model, device="cuda:0")
processor.process_video(
    input_path="your_video.mp4",
    mask_path="your_mask.png",
    output_path="results",
)

Three lines. Drop it into your existing pipeline.

How It Compares

Tool	Hair Detail	Temporal Consistency	Transparency	Green Screen Required
Premiere Roto Brush	Manual labor	Decent	Poor	No
Online Matting Tools	Average	Poor (flickers)	Not supported	No
Traditional Green Screen	Good	Good	Good	Yes
MatAnyone2	Excellent	Excellent	Excellent	No

The Bottom Line

I've been doing video post-production long enough to be skeptical of anything that promises "one-click" results. Most of them look great in the demo reel and fall apart on real footage.

MatAnyone2 is different. It's not approximate segmentation dressed up as matting. It's genuine pixel-level alpha estimation, trained on 2.4 million frames of real-world video, with a built-in quality evaluator that ensures the model only learns from its best work.

If you do short-form content, film post-production, virtual streaming, or just want to swap the background on a home video — give this a try. It might change how you think about video extraction entirely.

GitHub: https://github.com/pq-yang/MatAnyone2

Live Demo: https://huggingface.co/spaces/PeiqingYang/MatAnyone2

One-Click Deploy Package: https://www.patreon.com/posts/154208684

Automating Clinical Data Analysis: The Pipeline From Hospital Exports to Paper Drafts

local ai — Sat, 28 Mar 2026 09:31:16 +0000

Automating Clinical Data Analysis: The Pipeline From Hospital Exports to Paper Drafts

I've been building Data2Paper — a tool that turns research data into complete paper drafts. The latest challenge: handling clinical datasets from hospital systems.

If you've never worked with hospital data exports, here's what makes them... fun.

The input problem

A typical clinical data export looks like this:

PatientID | Age | Sex | HbA1c | SBP | DBP | eGFR | Dx | AdmDate | DisDate | Status
001       | 67  | M   | 8.2   | 145 | 92  |      | T2DM | 2024-01-15 | 01/25/2024 | alive
002       | 54  | F   |       | 128 | 78  | 85   | 2型糖尿病 | 20240203 | 2024-02-10 | 
003       | -5  | M   | 7.1   | 300 | 85  | 92   | type 2 DM | 2024-03-01 | 2024-03-08 | dead

Notice: three different date formats in the same column, the same diagnosis coded three different ways, an obviously wrong age, a systolic BP that's probably a data entry error, missing values that could mean "not tested" or "not recorded," and mixed languages.

This is normal. Every clinical researcher I've talked to confirms: this is what the export looks like.

The analysis pipeline

Raw export (CSV/XLSX)
│
├─ Structure detection
│   └─ row = patient? visit? wide? long?
│
├─ Data cleaning
│   ├─ Date format standardization
│   ├─ Coding unification ("T2DM" = "2型糖尿病" = "type 2 DM")
│   ├─ Outlier flagging (SBP=300, Age=-5)
│   └─ Missing value classification (not tested vs not recorded)
│
├─ Variable typing
│   ├─ Continuous (age, HbA1c, eGFR)
│   ├─ Categorical (sex, diagnosis, comorbidities)
│   └─ Time-to-event (survival time + censoring status)
│
├─ Statistical analysis (Python execution)
│   ├─ Baseline table with per-variable test selection
│   ├─ Regression (logistic / Cox / linear / Poisson)
│   ├─ Survival analysis (KM + log-rank)
│   └─ Diagnostic evaluation (ROC + AUC)
│
└─ Output generation
    ├─ Formatted tables (baseline, regression results)
    ├─ Figures (KM curves, ROC curves, forest plots)
    └─ Manuscript sections (methods + results)

Key technical decisions

Python execution, not LLM computation. Statistics must be verifiable. The LLM writes the interpretation; scipy, statsmodels, and lifelines compute the numbers.

Clinical variable lookup. Recognizing "SBP" as systolic blood pressure enables domain-aware outlier detection (flag 300 mmHg as likely error) rather than purely statistical outlier methods.

Assumption checking. Every statistical test includes prerequisite verification — normality for parametric tests, events-per-variable for logistic regression, proportional hazards for Cox. Running analysis without assumption checks is the #1 reason clinical papers get sent back by reviewers.

The baseline table problem

Generating Table 1 (baseline characteristics) sounds simple but requires per-variable logic:

for variable in dataset:
    if is_categorical(variable):
        # n (%), chi-square or Fisher's exact
    elif is_normal(variable):
        # mean ± SD, t-test or ANOVA
    elif is_skewed(variable):
        # median (IQR), Mann-Whitney or Kruskal-Wallis

The tricky part is automating the normality decision and handling the edge cases (small cell counts triggering Fisher's instead of chi-square, for instance).

Stack

Next.js + Vercel
Claude API for text generation
Python chain for statistical computation
Export: PDF / DOCX / LaTeX / ZIP
7 output languages

What I'm still figuring out

Better heuristics for distinguishing "not tested" vs "not recorded" missing values
Automated detection of wide vs long format in longitudinal datasets
Handling mixed-language clinical notes in the same dataset

If you've worked on similar problems — clinical data pipelines, automated statistical analysis, or structured document generation from data — I'd love to compare notes.

datatopaper.com

How to Create Medical and Science Book Illustrations With AI

local ai — Sun, 22 Mar 2026 13:17:56 +0000

How to Create Medical and Science Book Illustrations With AI

Medical and science publishing has a very specific illustration problem.

You do not just need a figure that looks good. You need one that explains clearly, survives multiple review rounds, stays consistent across chapters, and can be reused in print pages, lecture slides, LMS modules, and translated editions.

That is why AI is becoming useful in this space. Not because it replaces editorial judgment, but because it speeds up the first draft and makes figure production more scalable.

In this article, I will walk through a practical workflow for creating medical book illustrations, science book figures, and textbook diagrams with AI, while keeping the output usable for real publishing work.

If you want a tool built specifically for this workflow, visit SciDraw.

Original image link: https://cdn.xueshu.fun/202603201935059.png

Why Textbook Illustrations Need a Different Workflow

A figure for a medical or science book has a higher bar than a generic marketing visual.

It usually needs to satisfy five constraints at the same time:

It must be consistent with other figures in the same book.
It must be easy to edit after author, editor, or reviewer feedback.
It must work across print, presentation, and digital teaching formats.
It must support localization for future translated editions.
It must prioritize scientific clarity over decoration.

This changes the goal completely.

The goal is not to generate a beautiful one-off image. The goal is to build a figure system that is accurate, reusable, and inexpensive to revise.

Original image link: https://cdn.xueshu.fun/202603201938377.png

The Five Illustration Types That Appear Again and Again

In most medical and science book projects, the same visual patterns keep coming back. Once you recognize them, prompting becomes much easier.

1. Mechanism Diagrams

These explain how something works, such as immune pathways, signaling cascades, drug mechanisms, or physiological feedback loops.

2. Anatomy and Structure Figures

These focus on labeled structures, including organs, tissue layers, anatomical landmarks, and system overviews.

3. Process and Workflow Figures

These help readers follow a sequence, such as a diagnostic pathway, treatment algorithm, lab procedure, or experimental workflow.

4. Comparison Figures

These are useful when teaching differences, such as normal vs. diseased states, before vs. after treatment, or side-by-side techniques.

5. Chapter Summary Figures

These compress an entire chapter into one visual and help readers retain the main logic, sequence, or takeaways.

When you classify the figure correctly before prompting, the review cycle usually gets shorter and the result is much easier to refine.

A Practical AI Workflow for Book Illustrations

Here is the workflow that tends to work best for authors, editors, and educators.

Step 1: Start With the Teaching Objective

Before writing any prompt, define the job of the figure.

Ask:

What should the reader understand after looking at it?
Is this mainly a mechanism, a structure, a process, or a comparison?
What absolutely needs to be labeled?
What should be simplified or left out?

If the teaching objective is vague, the figure usually becomes visually crowded no matter how polished it looks.

Step 2: Prompt From Structure, Not Style

Strong textbook prompts start with content structure instead of decorative adjectives.

For example:

Create a medical book illustration explaining type II hypersensitivity.
Use a horizontal educational layout with 3 numbered sections:
1. Antibody binding to cell-surface antigen
2. Effector activation (complement / Fc receptor mediated response)
3. Target cell damage

Use clean textbook styling, white background, blue-teal-red palette,
clear arrows, concise English labels, and publication-ready hierarchy.

This works because it defines:

the learning goal
the layout
the sequence
the labeling logic
the general visual direction

Step 3: Generate the First Draft Quickly

At this stage, speed matters more than perfection.

The first draft only needs to answer four questions:

Is the structure right?
Are the labels in the right general positions?
Does the flow make sense?
Is the density appropriate for the chapter?

Think of the first output as editorial scaffolding, not final artwork.

Step 4: Edit for Publishing Logic

This is where the real quality comes from.

Refine the draft for:

terminology
label order
arrow direction
color meaning
spacing
caption compatibility
visual hierarchy

AI gets you to a strong draft faster. Editorial work makes it publishable.

Original image link: https://cdn.xueshu.fun/202603201939133.png

Step 5: Reuse the Base Figure Across Formats

This is where the time savings compound.

A good book illustration should be reusable in:

print chapters
lecture slides
online teaching modules
instructor guides
translated editions

If every figure is built as a dead-end asset, the production cost stays high. If figures are built as reusable teaching components, the workflow becomes much more efficient.

Prompt Templates You Can Use Immediately

Here are a few prompt patterns that work well for common textbook illustration tasks.

Medical Mechanism Figure

Create a medical book illustration for [topic].
Target audience: [undergraduate / graduate / professional training].
Use a [horizontal / vertical] textbook layout with [number] sections.
Show [key actors] and [key events] in logical sequence.
Include concise English labels, arrows for causal flow, and a clean
white background. Use a professional educational style with strong
visual hierarchy and publication-ready clarity.

Anatomy Overview

Create an anatomy diagram for a medical textbook.
Topic: [organ / system / structure].
Show the major labeled regions only, not every fine detail.
Use a clean educational style, legible English labels, subtle color
coding, and a balanced layout suitable for print and lecture slides.

Comparison Figure

Create a comparison illustration for a science book.
Compare [condition A] vs [condition B].
Use a two-column layout with matched scale, mirrored organization,
and clear difference callouts. Keep labels concise and make the
visual contrast obvious without clutter.

Workflow or Decision Pathway

Create a workflow figure for a medical or science textbook.
Topic: [diagnostic pathway / treatment algorithm / lab process].
Use numbered steps, directional arrows, short labels, and a clear
start-to-end reading path. Make it easy to reuse in both print and
presentation formats.

How to Keep a Whole Book Visually Consistent

One of the biggest mistakes in book production is treating every figure as a separate art project.

A better approach is to define a visual system at the beginning:

one core color palette
one label style
one arrow style
one spacing rule
one callout pattern

Then reuse those rules in every prompt.

For example:

Use the same visual system as previous chapter figures:
white background, teal primary structures, orange emphasis,
dark gray labels, rounded panel boxes, thin directional arrows,
minimal shadows, publication-ready textbook style.

That single paragraph can save hours of revision over the course of a full book.

Original image link: https://cdn.xueshu.fun/202603201940704.png

A Simple Quality Checklist Before Finalizing a Figure

Before approving a figure for publication, check the following:

Are labels short enough to survive translation later?
Is the figure still readable when reduced on a printed page?
Can the same composition work in slides or LMS layouts?
Are colors supporting explanation instead of acting as decoration?
Does each panel communicate one clear teaching point?
Can an editor or co-author revise it without rebuilding everything?

If the answer is yes, the figure is doing real publishing work, not just visual work.

Final Takeaway

The most effective workflow for medical and science book illustrations is not "AI instead of editing."

It is "AI for the first 80%, followed by a reusable editorial workflow for the last 20%."

That approach gives authors and educators three concrete advantages:

faster figure production
easier revision
stronger visual consistency across the entire book

If your team is producing textbook diagrams at scale, the highest-leverage move is to build one reusable figure system and keep every new illustration inside that system.

Try SciDraw

If you want to turn chapter outlines, rough sketches, and reference images into clean, reusable scientific illustrations, visit SciDraw.

SciDraw is built for scientific and medical visuals that need to work across books, slides, and digital courseware.

I built an AI tool that turns survey data into research papers — here's the architecture

local ai — Sun, 22 Mar 2026 08:56:46 +0000

I built an AI tool that turns survey data into research papers — here's the architecture

Hey DEV community! I'm a solo founder building AI tools for researchers. My latest product is Data2Paper — it takes raw survey/questionnaire export data and produces complete research paper drafts.

The problem

Researchers collect survey data → export CSV → spend weeks turning it into a paper.

The manual workflow looks like this:

Clean the exported data (fix encoding, remove junk rows, identify the actual response sheet)
Recode variables and set up analysis frameworks
Run statistical tests in SPSS/R/Python
Build tables and charts
Write methodology, results, and discussion sections
Format everything into a deliverable document

Data2Paper compresses that entire workflow into a single pipeline.

Architecture overview

┌─────────────┐
│  Upload      │  CSV / XLSX / XLS
│  (Survey     │  from any questionnaire platform
│   Export)    │
└──────┬──────┘
       │
       ▼
┌─────────────┐
│  Data        │  Identify response sheet vs summary
│  Intake      │  Parse machine headers (Q1, SC2...)
│              │  Detect variable types
└──────┬──────┘
       │
       ▼
┌─────────────┐
│  Analysis    │  Python execution chain
│  Engine      │  Statistical tests based on variable types
│              │  Generate charts & tables
└──────┬──────┘
       │
       ▼
┌─────────────┐
│  Paper       │  Multi-language (7 languages)
│  Generation  │  Full academic structure
│              │  Claude API
└──────┬──────┘
       │
       ▼
┌─────────────┐
│  Export      │  PDF / Word / LaTeX / ZIP
│  & Delivery  │
└─────────────┘

Key technical decisions

Why Python execution instead of LLM-generated stats?

Language models can hallucinate numbers. For a research tool, that's unacceptable. The analysis engine runs actual Python code to compute statistics — correlation, regression, chi-square, ANOVA, etc. The LLM interprets the results, but doesn't generate them.

Why survey-specific, not generic?

Generic "data to text" tools don't understand that row 1 might be a machine header, that columns might represent Likert scales, or that the first sheet might be a summary rather than raw data. By focusing specifically on survey exports, the system handles these patterns reliably.

Why multi-language from day one?

Research is global. A tool that only outputs English misses a huge segment of users — Chinese grad students, European consulting teams, Japanese research groups. Supporting 7 languages in the generation pipeline (not as translation) was a deliberate product decision.

Tech stack

Frontend/Backend: Next.js on Vercel
AI: Claude API
Analysis: Python execution chain
Payments: Stripe
Export: PDF, DOCX, LaTeX rendering

Try it

If you work with survey data or know someone in academia who does: datatopaper.com

I'd love feedback from the DEV community, especially around the analysis pipeline design and the multi-language generation approach. Drop a comment or reach out!

How to Check If a Scientific Figure Is Ready for Journal Submission

local ai — Tue, 17 Mar 2026 06:38:34 +0000

How to Check If a Scientific Figure Is Ready for Journal Submission

The Problem

You're about to submit a paper. The manuscript is polished. Then the journal upload system starts asking about figure resolution, format, and dimensions.

Sound familiar?

Most figure rejections aren't about bad science — they're about bad file hygiene. The figure looks fine on your 4K monitor, but at final print width, it's blurry. Or the JPEG compression has been quietly eating your axis labels. Or your red-vs-green comparison chart is invisible to 8% of male readers.

Here are the four checks every figure needs before you hit "Upload."

Check 1: Effective DPI ≠ File DPI

The trap: You exported at 300 DPI. You're safe, right?

The reality: DPI metadata means nothing without knowing the final placement width.

Image: 2400 × 1600 pixels
Exported at: 300 DPI

At single-column (85 mm / 3.35"):
  → Effective DPI = 2400 ÷ 3.35 = 716 DPI ✅

At double-column (180 mm / 7.09"):
  → Effective DPI = 2400 ÷ 7.09 = 338 DPI ✅ (barely)

At full-page (210 mm / 8.27"):
  → Effective DPI = 2400 ÷ 8.27 = 290 DPI ⚠️ (below threshold)

Takeaway: Always check DPI against the actual column width your figure will occupy.

Check 2: File Format Matters

Your figure has...	Use	Avoid
Text, labels, arrows, line art	TIFF, PDF, EPS, SVG	JPEG
Photographs, microscopy	TIFF, high-quality JPEG	Low-quality JPEG
Mixed content	TIFF, PDF	JPEG

Why? JPEG compression creates artifacts around sharp edges. Every re-save makes it worse. If your figure has any text or line work, JPEG is risky.

Also watch out for:

Unexpected transparency/alpha channels (some journals can't handle them)
RGB vs. CMYK color mode mismatches
Files that have been re-exported multiple times (quality degrades cumulatively)

Check 3: Grayscale Readability

Many reviewers print papers in black and white. If your figure relies entirely on color to convey information, it may become unreadable.

Common failures:

Two data series with different colors → same gray value
Heatmap gradients → flat gray blob
Colored annotations → invisible against background

Quick test: Open your figure in any image editor, convert to grayscale, and check if every element is still distinguishable.

Check 4: Colorblind Safety

Color vision deficiency affects ~8% of males and ~0.5% of females. The most common type makes red and green look nearly identical.

High-risk patterns:

Red vs. green for different conditions
Multiple saturated hues without pattern/shape backup
Color as the only way to distinguish data series

Fix: Use colorblind-safe palettes, add markers or line style variations, and include direct labels where possible.

Preflight Workflow

Step 1 → Use the actual file you'll submit (not a draft)
Step 2 → Set the target layout width
Step 3 → Run all four checks
Step 4 → Keep / Re-export / Redraw

Quick Decision Guide

Result	What to do
✅ All clear	Submit
⚠️ Format or DPI warning	Re-export with better settings
❌ Grayscale or colorblind fail	Adjust colors, add labels/patterns
❌ Resolution too low	Re-render at higher resolution or use vector format

Submission Checklist

[ ] Figure checked at actual final column width
[ ] Effective DPI ≥ 300 at that width
[ ] Format is safe for text and line work
[ ] Readable in grayscale
[ ] Key distinctions pass colorblind simulation

Try It

SciDraw Figure Checker runs all four checks automatically. Upload a figure, set your target width, and get a preflight report.

Other useful tools:

🔄 SciDraw Converter — Convert between TIFF, EPS, PDF with DPI/CMYK control
🎨 SciDraw AI Drawing — Generate scientific illustrations from text descriptions

What's your worst figure submission horror story? Drop it in the comments 👇

I Ran LTX 2.3 Locally — Image to Video with Audio, No Cloud Required

local ai — Sun, 08 Mar 2026 11:34:23 +0000

I Ran LTX 2.3 Locally — Image to Video with Audio, No Cloud Required

Last Wednesday night, I got my 12th "content policy violation" of the month.

I wasn't doing anything illegal. Just a portrait photo, a simple motion prompt. The kind of thing any filmmaker would shoot on set.

The platform didn't care. The error message was the same cold boilerplate it always is.

That was the moment I decided I was done with cloud video generation.

Two hours later, someone dropped a link in a Discord server I'm in.

"LTX 2.3 GGUF is out. Runs on consumer GPUs. Image-to-video with native audio."

I stared at that message for a few seconds.

Native audio. Not dubbed afterward. Not a separate step. Generated alongside the video, synchronized, as one output.

I closed the browser tab with the content violation error and started downloading the model.

What is LTX 2.3?

LTX-Video is an open-source video generation model from Lightricks, an Israeli company that's been in the media processing space for a while. Version 2.3 is their most capable release yet, and what makes it genuinely interesting compared to everything else out there:

It generates video and audio simultaneously.

Not video first, then audio layered on top. The model jointly produces both streams — synchronized dialogue, ambient sound, environmental audio — as a single generation pass. That's architecturally different from most pipelines where audio is an afterthought.

Other notable upgrades in 2.3:

Redesigned VAE for sharper fine details (hair, fabric texture, edges)
Significantly improved image-to-video quality
4K resolution support at up to 50 FPS
Better prompt understanding and camera motion control
Portrait (9:16) support alongside landscape

The base model sits at 19 billion parameters. Running it at full precision would require 38GB+ VRAM — firmly in server territory.

Then GGUF happened.

Why GGUF Changes Everything

The short version: GGUF is a quantization format that compresses model weights from 16-bit floats down to 4-bit (or lower). Same model, roughly one-fifth the size.

The version I'm using is Q4_K_S — about 10.7GB for the main model file. My GPU is an RTX 3080 with 10GB VRAM. The text encoder (Gemma 3 12B) offloads to CPU/RAM. Main model runs on GPU.

Result: a 5-second, 960×544 video with audio in about 2-3 minutes.

Is that fast? No. Is it running entirely on my own hardware, with no cloud, no API calls, no usage logs? Yes.

That trade-off is completely worth it to me.

What the Output Actually Looks Like

I ran an image-to-video test with a portrait photo. The prompt was minimal — I wanted to see what the model would do with almost no direction.

Input image:

First output:

Your browser doesn't support video playback.

Second test with a different input:

Your browser doesn't support video playback.

Honest assessment: it's not perfect. At Q4 quantization you lose some sharpness compared to the full BF16 model. Motion can be slightly jerky on complex scenes.

But the audio synchronization is genuinely impressive. And more importantly — this ran on my desk, with no data leaving my machine.

The Privacy Argument (And Why It Actually Matters)

Let me be direct about something most AI tool reviews dance around.

Every image you upload to a cloud video generation service is stored on someone else's server. Every prompt you type is logged. Every generation becomes part of your usage profile. The terms of service you clicked through without reading probably give them broad rights to that data.

I'm not being paranoid. This is just how SaaS works.

Local inference changes the equation completely. The model lives on your hard drive. Inference runs on your GPU. The output files go to your output folder.

The entire pipeline is air-gapped from the internet.

No usage logs. No content moderation API calls. No third party with visibility into what you're creating.

If you're working on creative projects that might not survive a content policy review — not because they're harmful, but because algorithms are bad at context — this matters.

What you create is between you and your hardware.

Hardware Requirements

Here's what you actually need:

Component	Minimum	Recommended
GPU	RTX 3080 10GB	RTX 4080 16GB+
RAM	32GB (text encoder on CPU)	64GB
Storage	30GB free	50GB+
OS	Windows 10/11	Windows 11

Model files you need:

Main model: LTX-2.3-distilled-Q4_K_S.gguf (~10.7GB)
Text encoder: Gemma 3 12B fp4 + LTX text projection layer
Video VAE: LTX23_video_vae_bf16.safetensors
Audio VAE: LTX23_audio_vae_bf16.safetensors
LoRA: LTX-2-Image2Vid-Adapter.safetensors

If your VRAM is under 12GB, the text encoder (Gemma 3 12B) will run on CPU. You'll need 32GB of system RAM for that to work without swapping to disk.

One-Click Setup

I've packaged a complete pre-configured environment that includes:

Full ComfyUI installation with all required custom nodes pre-installed
All model files (no separate downloads needed)
A Gradio web interface — just open a browser, upload an image, write a prompt, hit generate
Pre-tuned workflow matching the settings that produced the videos above

Double-click 01-run.bat. Browser opens. Generate.

No Python environment setup. No node installation. No YAML configuration. It just works.

Download: https://www.patreon.com/localai

A Note on What This Enables

I've been running local AI models for a few years now. What's changed recently isn't the existence of local models — it's the capability gap closing.

Twelve months ago, local video generation was a curiosity. The outputs were bad enough that cloud services, despite their restrictions, were clearly better.

That's no longer true.

LTX 2.3 at Q4 quantization produces outputs that are competitive with mid-tier cloud services. And it does something cloud services can't do by design: it generates audio and video together, in a single pass, with no content filtering, on hardware you own.

That's a meaningful shift.

The technology for completely private, unrestricted, high-quality video generation now fits on a consumer GPU. What people do with that capability — the creative projects they pursue, the content they make — is genuinely up to them.

That's new.

Download the one-click package: https://www.patreon.com/posts/ltx-2-3-locally-152521808

Running questions? Drop a comment. I respond to most of them.

Applying Constrained Generative AI to USPTO Design Patent Figure Production

local ai — Sat, 07 Mar 2026 12:29:11 +0000

Design patent drawings present an underexplored constrained generation problem: produce technically compliant multi-view technical illustrations from 3D inputs, where compliance is formally specified and verifiable.

The Task Definition

USPTO design patent applications require a minimum of 7 orthographic and perspective views of the claimed design. Compliance constraints include:

Line weight consistency across all views (rejections triggered by inter-view variance)
Surface shading conventions derived from historical technical illustration standards (contour shading, stippling for transparency, oblique strokes for metallic surfaces)
Broken line semantics: dashed lines indicate unclaimed subject matter; solid lines indicate claimed subject matter. The boundary must be unambiguous across all views simultaneously.
Completeness: every geometric feature visible in any view must be consistently disclosed in all views where it would be visible

This is a structured prediction problem with a formal evaluation criterion (USPTO examiner acceptance / 112 rejection rate).

Why This Is Non-Trivial

Standard image-to-image or 3D rendering pipelines don't solve this directly. Challenges include:

Cross-view consistency is a global constraint—not a per-image property. Each view must be checked against all others.
Shading semantics are perceptual, not photorealistic. Patent shading communicates surface type to a human examiner, not lighting simulation.
Broken line placement is a legal/strategic decision, not a visual one. The model must support human-in-the-loop control over claim boundary designation.
Domain gap: training data for USPTO-compliant line art is limited compared to general CAD or technical illustration datasets.

PatentFig: Applied Approach

PatentFig is a production system we built to address this pipeline. It accepts 3D models, CAD screenshots, or sketches as input and generates USPTO-compliant multi-view figures.

Key design decisions:

Separate the geometric projection step (deterministic, rule-based) from the stylization step (learned)
Human-controlled broken-line toggle rather than attempting to infer claim strategy from geometry
Output validated against known rejection categories before delivery

The system currently handles the full 7-view generation workflow and is live at patentfig.ai.

Open Questions

Genuinely curious whether anyone in this community has worked on related problems:

Multi-view consistency as a training objective (beyond just single-image quality)
Domain adaptation for technical illustration styles with small training sets
Formal verification of structured visual output against rule-based compliance specs

Happy to discuss technical tradeoffs or share more about the architecture. Comments open.

→ patentfig.ai

InfiniteTalk: I Gave a Portrait a Voice. It Took One Audio File and Zero Cloud Services.

local ai — Sat, 21 Feb 2026 03:35:34 +0000

InfiniteTalk: I Gave a Portrait a Voice. It Took One Audio File and Zero Cloud Services.

Last month, a client asked me to create a product demo video with a real human presenter.

Outsourcing quote: $1,100.

What I actually spent: three days and electricity.

Here's how.

The Problem With Every "AI Avatar" Tool I've Tried

I've tested most of the major players. HeyGen. D-ID. Synthesia. Runway.

They work. But they come with baggage:

They're expensive. You get a few minutes of generation time and then you're paying again. Fine for one-offs. Terrible for any kind of volume.

They log everything. Every portrait you upload, every script you type—it lives on their servers. I found this out the uncomfortable way when a roleplay scenario I was working on got flagged by their content moderation. Nothing illegal. Just "not within acceptable use."

The output feels dead. The mouth moves. Everything else doesn't. No head micro-movements. No blinking. No natural shoulder motion. It looks like a talking photograph, not a person.

I needed something local.

Found on GitHub at 1 AM

I was scrolling through GitHub trending when I found InfiniteTalk by MeiGen-AI.

Three lines in the README made me stop:

"Unlimited-length talking video generation"
"lip sync + head movements + body posture + facial expressions"
"runs locally on consumer hardware"

The model is built on Wan2.1—the same model family that's been quietly dominating the open-source video generation space.

I cloned the repo.

The First Result Stopped Me Cold

One portrait. One audio clip. Thirty seconds of generation time.

The lips moved. I expected that.

What I didn't expect: the head tilted slightly. The eyes blinked. The shoulders had that subtle rise-and-fall you get when someone's actually speaking.

Not mechanical bobbing. Not a canned animation loop. The kind of micro-movement that happens when a person's body is actually responding to what they're saying.

I generated it again with different audio. Same natural quality.

Why This Works When Others Don't

Traditional lip-sync tools—SadTalker, MuseTalk, most of what you'll find on GitHub—share a fundamental approach: they only touch the mouth.

Take a video, isolate the mouth region, replace it with audio-driven mouth movement, leave everything else alone.

The problem is obvious once you say it out loud: when a real person talks, nothing is stationary. The head nods. The brow moves. The shoulders track breathing.

Fix only the mouth and you get an uncanny valley effect that's hard to articulate but immediately obvious.

InfiniteTalk takes a different approach. It doesn't patch a video. It generates a new one.

Input: portrait + audio.
Output: a video synthesized from scratch, where audio drives not just the lips but the entire body's motion pattern.

The benchmark numbers back this up:

InfiniteTalk lip error: 1.8mm
MuseTalk: 2.7mm
SadTalker: 3.2mm

That 0.9mm gap between InfiniteTalk and MuseTalk is the difference between "convincing" and "almost convincing."

What "Unlimited Length" Actually Means

Default generation is 81 frames—about 3 seconds at 25fps.

But 3 seconds isn't a ceiling. It's a unit.

InfiniteTalk uses a sparse-frame context window: after each chunk generates, it passes the final frames forward as reference material for the next chunk. The result is seamless continuity—same identity, same background stability, same audio-lip alignment—across arbitrarily long videos.

I tested a 3-minute clip. No identity drift. No background flicker. Lip sync held throughout.

Here's a second example:

Hardware Requirements

You don't need a top-tier GPU.

480p: 6GB VRAM minimum
720p: 16GB+ recommended

I'm running an RTX 3090. A 3-second 480p clip takes 30-60 seconds to generate. Not instant, but perfectly workable for the quality you get.

Models you'll need:

Wan2.1_I2V_14B_FusionX-Q4_0.gguf (quantized main model, VRAM-friendly)
wan2.1_infiniteTalk_single_fp16.safetensors (InfiniteTalk patch)
wav2vec2-chinese-base_fp16.safetensors (audio encoder)
Supporting VAE, CLIP, LoRA weights

All available on Hugging Face or regional mirrors.

One-Click Setup, No Code Required

We wrapped the ComfyUI workflow in a Gradio web interface for easier use.

Launch: double-click 01-run.bat. Browser opens to http://localhost:7860 automatically.

Left panel inputs:

Portrait image (any format)
Audio file (WAV or MP3)
Text prompt (affects motion style, not content)

Right panel: generated MP4, ready to play and download.

Advanced settings let you adjust resolution (256–1024px), frame count, and sampling steps. Defaults work fine for most use cases.

The Part You're Probably Thinking About

This runs entirely on local hardware.

No cloud processing. No usage logs. No content moderation system watching what you generate.

What portrait you use, what audio you provide, what you create with it—

Your hardware. Your call.

I'll leave the implications of that to your imagination.

Closing

The client got their video. They asked which production company I'd used.

I told them I'd generated it at home, on my own machine.

Two seconds of silence.

"Can you do the second episode too?"

Yes.

One-click download: https://www.patreon.com/posts/151286461

I tried automating patent figure creation — here's what actually worked

local ai — Fri, 20 Feb 2026 13:46:28 +0000

If you've ever had to prepare a patent application, you know the figures are a pain. Not intellectually hard, just tedious and surprisingly expensive if you're outsourcing them.

I spent some time testing AI tools in this space and want to share what I found for anyone else going through the same process.

The problem with most "AI drawing" tools for patents

Most general image generators produce things that look cool but are useless for patent filing:

They use shading and color (not allowed)
No reference numerals
Non-standard line weights
No export at required DPI
Can't generate consistent multi-view sets

So I was looking specifically for tools that understand patent drawing requirements, not just "technical illustration."

What I tested

After trying a few options, the one that actually addressed the workflow properly was PatentFig.

The flow is:

Upload a reference image (product photo, sketch, CAD screenshot) or just describe the invention in text
Choose which views you need (front, side, top, perspective, cross-section, flowchart...)
Generate — it produces line art with reference numerals and leader lines
Modify via chat ("move numeral 3 to the left", "add a detail view of this section")
Export as PDF/PNG/SVG/TIFF at filing specs

What worked well

Flowcharts and block diagrams: excellent. Software patent figures came out clean and filing-ready
Simple product line art from photos: surprisingly good for consumer goods
Chat-to-modify: this is the feature that makes iterating actually practical
Multi-jurisdiction export: switching between USPTO and CNIPA formatting is a dropdown

What was harder

Complex mechanical assemblies with many moving parts: needed more iteration rounds
Reference numeral placement on crowded figures: sometimes needed manual adjustment

Pricing context

Free tier gives 20 credits/month (enough to test the workflow). Paid starts at $40/month billed annually. For a patent agent filing regularly, the time savings vs. outsourcing figures probably pays for itself within the first application.

Bottom line

If you're a solo inventor, startup founder, or patent agent handling your own figures, this is worth a test on your next application. The free tier is genuinely usable for evaluation.

Drop a comment if you've tried other approaches — curious what workflows others have landed on.

How I Built an AI Tool for Scientists and Grew to 10K Users as a Solo Founder

local ai — Mon, 02 Feb 2026 11:46:30 +0000

Hey dev community! 👋

I want to share my journey building a niche AI SaaS product as a solo founder. Hopefully, some insights here will be helpful for others on a similar path.

The Problem I Noticed

While working with researchers, I noticed a recurring pain point: scientists spend hours creating figures for their papers. Most use PowerPoint or struggle with Illustrator, even though they're not designers. The results often look unprofessional, and the process is frustrating.

The Solution

I built SciDraw - an AI-powered platform specifically for scientific illustrations. Researchers can describe what they need or upload a rough sketch, and the AI generates publication-ready figures.

Key features:

Text-to-image generation for scientific concepts
Sketch refinement (turn rough drawings into polished diagrams)
Editable SVG export (so users can fine-tune in any vector editor)

Tech Stack

For those curious about the technical side:

Frontend: Next.js + React
Backend: Node.js
AI: Custom pipeline combining multiple image generation models
SVG Processing: Custom algorithms to ensure clean, editable vector output

What Worked for Growth

I didn't have a marketing budget, so I focused on:

SEO - Targeting long-tail keywords like "AI scientific figure generator"
Directory submissions - Listed on 80+ platforms (Product Hunt, G2, etc.)
Niche focus - Instead of competing with general AI image tools, I went deep into one vertical

Current Stats

10,000+ researchers using the platform
~$2K MRR
Users from Stanford, MIT, Harvard, and universities worldwide
Fully bootstrapped, no funding

Lessons Learned

Niche down aggressively - A small pond is easier to dominate
Solve a real pain point - Scientists were literally wasting hours; the value prop was obvious
Talk to users - Early feedback shaped the product significantly
SEO compounds - It's slow at first, but worth the investment

What's Next

Currently working on:

More diagram types (molecular structures, experimental workflows)
Collaboration features for research teams
API for integration with other tools

Happy to answer any questions about building for the academic market or AI image generation!

What niche are you building for? 👇