# posterly builds a conference poster as one HTML file, then prints it

> A Python coding-agent skill that reads a LaTeX paper, composes a poster at an exact canvas size, and checks the layout in code before anything reaches a printer, with a hosted tier that runs the same gates on rented engines.

**Chenruishuo/posterly** — Build academic conference posters as a single HTML/CSS file, rendered to print-ready PDF via headless Chromium. A coding-agent skill.

- Repository: https://github.com/Chenruishuo/posterly
- Stars: 416 · Forks: 10
- Language: Python
- License: AGPL-3.0
- Published: 2026-09-20 · Updated: 2026-09-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/chenruishuo-posterly

## The canvas size is written in inches and lands in the PDF

The unit of posterly is a single HTML and CSS file whose page size is declared in physical units. The concrete mechanism is a rule of the form `@page { size: 60in 36in }` handed to Chromium's `page.pdf()`, so the dimensions of the resulting PDF match the canvas instead of being approximated by a printer dialog. That is why the project accepts ICML, NeurIPS, ICLR and CVPR canvas sizes, plus a custom one, rather than asking you to trim a slide deck afterwards. The example PDFs in the repository come in two shapes: six at 60x36 in landscape, named evidence board, musical score, theatre, orrery, certificate and escort broadside, and three at 24x36 in portrait, named control panel, cartographic and heat treatment. Every one of those files is a direct output of the same print path, which makes the sizes comparable rather than aspirational.

## Overflow becomes a Playwright geometry query, not a squint

The argument for HTML and CSS over LaTeX posters is made through what becomes checkable. Editing CSS and refreshing the browser skips a recompile step. Flexbox, grid, gradients, `text-wrap: balance` and web fonts are available without stacking poster packages. And the important one: asking whether a column overflows turns into a Playwright geometry query instead of a visual guess, because a headless browser will report the box. The command-line checks in the pipeline target three specific defects before you print: overflow, misalignment, and styling that has drifted off the palette. Those checks are referred to elsewhere as the hard gates, and the dependency comment in pyproject.toml names four of them as HTML, measure, style and preflight. None of them can pass on a page whose measurements are guesses.

## The agent is told to stop at high effort

The most unusual instruction in the project is a ceiling on the model, not on the poster size. The README opens with a warning not to run posterly above `high` effort, and it applies that to GPT-5.6 Sol, to other GPT models, and to Claude Opus. The stated reason is behavioral: at higher effort these models tend to overthink, second-guess, or drift away from the workflow posterly requires, and the result is substantially worse posters. So `high` is named as the maximum recommended level, and a skill that would otherwise benefit from more reasoning is deliberately held back. The hosted service runs into the same constraint from the other side, where a GPT-only tier is offered at a quarter of the Claude and GPT price with the same hard gates.

## The install path refuses to run on base Python

The manual install exists, and it is written defensively. Every command in it uses a placeholder interpreter path that you are told to replace with the verified absolute path of a dedicated non-base environment, and the same interpreter must be used for tools, for `-m pip`, and for `-m playwright`. Base is ruled out and shell activation is ruled out, which is a stricter rule than most projects impose on themselves:

```bash
# 1. Clone where your agent discovers skills — e.g. ~/.claude/skills/ for Claude Code
#    (other agents: use their skills directory)
git clone https://github.com/Chenruishuo/posterly ~/.claude/skills/posterly
cd ~/.claude/skills/posterly

# 2. Python deps
/absolute/path/to/dedicated-env/bin/python -m pip install "playwright>=1.40"
/absolute/path/to/dedicated-env/bin/python -m playwright install chromium
# On a fresh Linux box you may also need the system libs Chromium links against:
#   /absolute/path/to/dedicated-env/bin/python -m playwright install --with-deps chromium
#   # or sudo
```

The clone target is the point of the whole exercise. posterly reaches an agent as a directory of skill files, so it goes where that agent looks for skills, such as `~/.claude/skills/` for Claude Code.

## A passing smoke test means PASS and two preview files

The install is verified by two scripts rather than by a version banner. The `poster_check.py` calls should print `PASS`, and `render_preview.py` should write `poster_preview.pdf` plus `poster_preview.png`. Everything else about the packaging follows from the same decision: posterly is clone-only, there is no PyPI distribution, and `pyproject.toml` exists to hold dependencies and pytest configuration rather than to be installed. That file pins the single runtime dependency at `playwright>=1.40`, adds pytest>=7 under a dev extra, and requires Python 3.10 or newer, with classifiers for 3.10, 3.11 and 3.12, OS Independent, and the project at version 0.1.0 marked as Beta. Pulling real figures from a submitted paper is the one place a second dependency set appears: a `figures` extra carries PyMuPDF>=1.23 and Pillow>=10 for three vendored ARIS tools, extract_pdf_figures.py, preprocess_figures.py and asset_check.py. That group is optional, needed only to pull or check real paper figures, and the HTML, measure, style and preflight gates do not require it. The quickest route in remains pasting one line at your agent: Install this skill for me, followed by the repository URL, which clones, installs and runs the smoke test.

## Math is typeset by MathJax and measured offline

Math is not handled natively by the browser. Templates load MathJax from a CDN when a poster file is opened directly, while the gate and preview renders serve a bundled copy instead. The reason is measurement: an offline copy means the geometry queries that decide whether an equation overflows its column can run without a network round trip, so the check and the thing being checked are not different documents. The same logic explains the HTML-first choice at a smaller scale. A preview you can refresh is a preview you can measure. The project points at `SKILL.md` for the details of how templates, gates and preview renders are wired together, which is where to look for the rendering specifics rather than the overview.

## Nine directions from one paper with the content held fixed

The example set is built to isolate design from content. One paper, PowerFlow, at arXiv 2603.18363 from ICML 2026, was run through the pipeline nine times with the paper and its content held fixed, so the only thing that varies between outputs is design. Each direction is composed from choices in layout, typography, palette, framing, density and masthead, which is why the result is described as nine examples rather than nine templates, and the template notes live in `templates/DESIGN-AXES.md`. Every one of the nine is said to pass the hard checks, which is the part that matters: the variation is not free-form styling that happens to look good, it is variation that survives the same measurement checks. The hosted gallery is the place to see more combinations than a repository can carry.

## The hosted tiers differ by engine, not by gate

There are two ways to run the pipeline and they differ in more than billing. The open-source skill is the clone described above, runs on your machine, and needs no posterly account. The hosted service at tryposterly.com runs it for you, has been open to everyone since 25 July 2026 with no invite and no waitlist, and charges per order with an itemized receipt, taking cards and, since 4 August 2026, WeChat Pay. It comes in two engine tiers: Claude plus GPT described as best practice, and GPT-only at a quarter of the price. The reasoning behind the cheaper tier is specific, that GPT-5.6-sol optimizes hard toward a stated goal, which made a recipe possible where GPT alone runs the whole pipeline in fewer rounds, at the cost of a little design flair. The project's own record of use is about 50 posters made at ICML 2026 in the first week of July 2026. One detail is worth noting for anyone searching: the README headline writes the name with a circled plus standing in for the o, which is how the wordmark reads.

## Conclusion

posterly fits a researcher who already drives a coding agent and wants the poster treated as a layout problem with checks attached, and it is a poor fit for anyone who wants a design tool with a visible canvas, since the composition happens inside the agent. Verify four things before you rely on it: the visible walkthrough stops right after the input step, so the gate definitions live in SKILL.md; the effort ceiling of high is a hard instruction, not advice; the only runtime dependency is playwright>=1.40 with Chromium installed separately; and AGPL-3.0 governs the clone, which matters if you intend to modify it and keep it internal. The hosted tier answers a different question and costs money per order.

## FAQ

### How do I install the posterly skill for a coding agent?

Clone it into the skills directory your agent reads, for example git clone https://github.com/Chenruishuo/posterly ~/.claude/skills/posterly, then install playwright>=1.40 and Chromium using a dedicated non-base interpreter. posterly is clone-only and is not published to PyPI.

### What effort level should posterly run at?

high is named as the maximum recommended level. The project warns against running above high on GPT-5.6 Sol, on other GPT models and on Claude Opus, because those runs tend to overthink or drift from the required workflow and produce substantially worse posters.

### Which conference poster sizes does posterly support?

ICML, NeurIPS, ICLR and CVPR canvas sizes, or a custom one. The example PDFs are 60x36 in landscape and 24x36 in portrait, and a rule of the form @page { size: 60in 36in } is passed to Chromium's page.pdf() so the PDF dimensions match the canvas.

### Does posterly need an account, and what does the hosted service charge?

The open-source skill runs on your machine from a clone and needs no account. The hosted service at tryposterly.com is pay-as-you-go, has been open to everyone since 25 July 2026, issues an itemized receipt per order, and offers two engine tiers: Claude plus GPT, or GPT-only at a quarter of the price.

### What license is posterly under, and who wrote it?

AGPL-3.0-only, declared in pyproject.toml with a LICENSE file, a LICENSES directory and a NOTICE.md at the repository root. The author field names Ruishuo Chen, and the repository is not archived, with the last commit landing on 27 September 2026.

## Sources

- [Chenruishuo/posterly on GitHub](https://github.com/Chenruishuo/posterly)
- [Issues](https://github.com/Chenruishuo/posterly/issues)
- [License: AGPL-3.0](https://github.com/Chenruishuo/posterly/blob/main/LICENSE)
- [README](https://github.com/Chenruishuo/posterly/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/chenruishuo-posterly