RenderCV: a YAML to PDF resume builder for academics and engineers

The problem RenderCV solves: a CV that is text, not a document

Most resume tools treat the document as the source of truth. You open an editor, drag a section, and the layout is whatever you last saved. That breaks down the moment you want two versions of a CV, or want to see what changed between the version you sent in January and the one you sent in June. RenderCV inverts this. The README states the premise directly: write your CV as YAML, run the CLI, get a PDF. The YAML is the artifact you keep, diff and branch; the PDF is a build output.

The audience is narrow on purpose. The project describes itself as a resume builder for academics and engineers, and the example CV in the README is a PhD from Princeton with a thesis title, an advisor and an NSF Graduate Research Fellowship. Publication lists, advisor names, fellowship lines and long education entries are the shape this tool was designed around. A two-page marketing resume with a photo and a skills bar chart is not the target, and the theme list reflects that: the README shows classic, engineeringresumes, sb2nov, moderncv, engineeringclassic, harvard, ink, opal and ember. Several of those names are borrowed from LaTeX resume templates that engineers already use, which tells you who the author had in mind.

How RenderCV works: YAML in, Typst out, validation in between

The pipeline has three visible stages. First, the YAML file is parsed and validated against a schema. The README calls this strict validation and frames it as a feature: "No surprises. If something's wrong, you'll know exactly what and where." The repository ships schema.json at the top level, and the README points out that the JSON Schema drives autocompletion and inline documentation in an editor. That is the mechanism behind the validation claim: the same schema that powers editor hints is the one the CLI enforces.

Second, the validated model is rendered. The typst topic on the repository, plus the project description, indicate the PDF is produced by Typst rather than LaTeX or a browser print path. Typst is a separate typesetting system, so the layout you get is not a Word template with your text poured in; it is generated from a template that consumes your structured data.

Third, design is applied from a design block in the same YAML. The README example shows theme, page size, margins, footer and top note toggles, a colors map with keys like body, name, headline, connections, section_titles, links, footer and top_note, and a typography block with line_spacing, alignment, date_and_location_column_alignment and font_family. The comment in that snippet ends with "...and much more", so the documented keys are a subset. The data flow is one-directional: nothing writes back into your YAML, and there is no database or server component in the described flow.

Installing RenderCV and rendering a first CV

The README's Get Started section gives one install command and notes a Python version requirement of 3.12 or newer. The extra is what pulls in the full rendering stack, so the bracket matters.

pip install "rendercv[full]"

Once installed, the CLI entry point is rendercv. The README's own example invocation renders a named YAML file:

rendercv render John_Doe_CV.yaml

To see what a complete input looks like before writing your own, the repository ships paired examples under examples/, one YAML and one PDF per theme, for instance examples/John_Doe_ClassicTheme_CV.yaml alongside examples/John_Doe_ClassicTheme_CV.pdf. Rendering the YAML should reproduce a PDF in the same family as the shipped one. The README's minimal document shows the top-level shape: a cv key holding name, location, email, website, a social_networks list with network and username, and a sections map whose keys become section headings.

cv:
  name: John Doe
  email: [email protected]
  social_networks:
    - network: GitHub
      username: rendercv
  sections:
    education:
      - institution: Princeton University
        degree: PhD
        start_date: 2018-09
        end_date: 2023-05

If you would rather not install anything locally, the repository contains a Dockerfile that builds a non-root image and sets the entry point to the rendercv CLI, with --help as the default command. There is also an AI agent skill installed with npx skills add rendercv/rendercv-skill, which the README says is generated from RenderCV's source and evaluated with promptfoo against RenderCV's own Pydantic validation pipeline.

Strict validation is the selling point and the sharp edge

RenderCV does not try to be forgiving. Where a word processor would let you type a date as "Summer 2022" and move on, the schema expects a structured value, and the README's example uses the form start_date: 2018-09. That is a real constraint on how you enter data, and it is deliberate: the date and location column alignment setting only makes sense if dates have a predictable shape.

The trade-off is that the tool is a poor fit when your CV content does not fit the schema. A section that is a paragraph of prose rather than a list of entries, a table of grants with columns the schema does not model, or a layout where the sidebar carries contact details, all push against the structured model. The README does not document an escape hatch for arbitrary layout, and the design block's "...and much more" is not an enumeration you can plan against. If your CV's value is in unusual visual structure rather than in consistent typography, a general document tool is the better choice.

There is a second limitation worth naming: the README does not document rollback or version pinning behaviour for the CLI, so if a future release changes the schema, the page gives no stated procedure for reverting to a working version beyond the usual package manager mechanics. The release history shows v2.6, v2.7 and v2.8, so the schema has moved recently.

RenderCV compared with LaTeX resume templates

The natural comparison is a LaTeX resume template, and the related searches show people make it. The difference is in what you edit. With a LaTeX template you edit markup: you write \section, \textbf, \begin{itemize} and you control line breaks when the page overflows. With RenderCV you edit data, and the layout comes from the theme and design block. You give up fine-grained control over where a line breaks; you gain the ability to add a job entry without re-reading a preamble.

The second difference is the toolchain. LaTeX requires a TeX distribution, which is large and whose package conflicts are a known time sink. RenderCV requires Python 3.12 or newer and installs from PyPI, and the Dockerfile shows it can be containerised cleanly. The shipped Dockerfile uses a two-stage build with uv, a non-root user, and the CLI as the entry point, which is a simpler deployment story than a TeX install if you want to render CVs in CI.

A third difference is validation. A LaTeX template will happily compile a document with a typo in a date; RenderCV's schema is described as catching the error and telling you where it is. For someone who updates a CV twice a year, that is a smaller benefit than for someone who keeps twenty variants in a repository.

Themes, language and the AI skill

Themes are the main reason to pick RenderCV over writing your own Typst template. The README shows nine, and several target specific conventions: engineeringresumes and engineeringclassic for engineering applications, harvard and classic for academic ones, moderncv and sb2nov carried over from widely used LaTeX templates. Each example PDF in the repository is paired with the YAML that produced it, so you can diff two YAML files to see what changes between themes rather than guessing from screenshots.

The locale block handles non-English CVs. The README's example shows language plus translated strings for last_updated, month, months, year, years, present and month_abbreviations. That is a fixed set of strings, not a translation framework, so a language whose date conventions differ structurally from the English defaults may need more than the documented keys. The README does not show a full locale file, only an excerpt ending in an ellipsis.

The AI agent skill is the newest surface. The README says it is auto-generated from RenderCV's source code and evaluated with promptfoo against RenderCV's own Pydantic validation pipeline, which is a stronger claim than most skill packages make. It is installed with npx skills add rendercv/rendercv-skill and is said to work with any agent supporting the skills standard. It is worth treating as a convenience layer over the same schema, not as a way to skip learning the YAML.

Licence, maintenance and what an upgrade costs

RenderCV is MIT licensed, which permits commercial use, modification and redistribution provided the copyright notice and permission notice are retained. That is a permissive licence with no copyleft obligation on your own work, so a CV built with it carries no licensing constraint on the content. This is a statement about the licence text, not legal advice; if you are redistributing the tool itself inside a product, read the LICENSE file in the repository.

The repository is not archived, and the last push was on 2026-05-01. The most recent release listed is v2.8 from 2026-03-21, preceded by v2.7 on 2026-03-06 and v2.6 on 2025-12-23. Two releases five weeks apart followed by a gap is a normal pattern for a tool of this size, but it does mean the schema is still moving.

The upgrade cost is mostly schema drift. Your YAML is the thing that can break, and there is no documented migration path between versions in the README. The practical mitigation is already built into the tool's premise: keep the YAML in Git, pin the package version you installed, and re-render the shipped example after an upgrade to confirm the output still matches before you touch your own file. The repository's justfile shows the maintainers run pytest with an --update-testdata flag, which implies rendered output is compared against stored fixtures, so visual changes between versions are something the project tracks deliberately.

Editorial conclusion

Adopt RenderCV if you want a CV that lives in Git as plain text and you accept that the YAML schema is the interface: the strict validation will reject a malformed date or a missing field rather than silently dropping it. Skip it if you need a drag-and-drop editor, or if your CV changes shape for every application and you would rather not edit YAML each time. Before committing, run rendercv render on the shipped example examples/John_Doe_ClassicTheme_CV.yaml and check that the theme you want appears in the generated PDF, since the README shows nine themes but does not document how much of a theme's layout is overridable versus fixed.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. README
4. Releases
5. rendercv/rendercv on GitHub