Documentation

The four formats

What each format is, how to run it, and what to edit to change the content.

Adjuvant ships the same design as four separate things. This document explains what each one is, how to run it, and, most importantly, what you edit and where, because the answer differs depending on how deep you want to go.

The short version

I want to	Do this	Need Python?
Put a website online	Upload `html/` to any host	No
Change wording, products, colours on that site	Edit the HTML and CSS in `html/` directly	No
Change wording, products, colours in every format at once	Edit JSON in `source/content/`, then rebuild	Yes
Use Hugo, Jekyll or JBake	Use that folder as a normal project	No, but each needs its own engine

You never need anything that is not in the ZIP. There is no separate "core" to buy, no licence server, no account, and no download that expires. source/ is the whole generator.

What each folder is

`html/` : the site, already built

Plain HTML, CSS and JavaScript. Open index.html in a browser and it works, including from a file path with no server. Upload the folder's contents to any host: shared hosting, S3, Netlify, Cloudflare Pages, a Raspberry Pi.

This is what most buyers use, and nothing else in the package is required to use it.

`hugo/` : a Hugo theme

A complete theme plus an exampleSite/. Hugo builds it into a static site.

cd hugo/exampleSite
hugo server --themesDir ../..
# open http://localhost:1313

To use it in an existing Hugo project, copy the theme folder into your themes/ directory and set theme = "adjuvant" in your config. Content lives in data/*.json, matching the same content model the other formats use.

`jekyll/` : a Jekyll site

A complete site, not just a theme, because the layouts and the content model belong together.

cd jekyll
bundle exec jekyll serve
# open http://localhost:4000

Content is in _data/*.json. Layouts are in _layouts/, sections in _includes/sections/.

`jbake/` : a JBake project

For JVM shops. Maven drives the build.

cd jbake
mvn generate-resources
# output in target/site

`source/` : the generator behind all four

The design tokens, the stylesheet, the behaviour modules, the markup partials, the content model, and the two build scripts. Editing here and rebuilding regenerates every format, which is what keeps them identical.

Do I need "core access" to change the externalized content?

No. This is the question the architecture exists to answer, so it is worth being explicit.

The content model is plain JSON files sitting in source/content/ inside your download. They are yours. Open them in any text editor. There is no hosted service, no API key, no subscription and no repository you need access to. If this project vanished tomorrow, every file you need would still be on your disk and still work.

What source/ gives you that editing html/ directly does not:

One edit reaches every format. Change the company name once and it updates the HTML, Hugo, Jekyll and JBake builds, plus the structured data, the sitemap and the page titles.
No hunting. Changing a product name by hand means finding it in the catalog page, the detail page, the schema.org block and the sitemap. In the content model it is one field.

If you only ever ship the HTML site, editing html/ directly is completely legitimate and fully supported. The documentation covers both routes. Use whichever suits you.

Adding a blog post or news article

This is the one thing you will want to do repeatedly, so each format supports it the idiomatic way: write a markdown file. You do not touch the content model, you do not rebuild anything, and nothing overwrites what you create.

Hugo

Create content/article/my-post.md:

---
title: "Second fill-finish line qualified"
description: "The standing-first paragraph, shown in a heavier weight."
tag: "Facilities"
article_date: "2026-08-14"
author: "Operations"
read_minutes: 4
---
Your opening paragraph. This one is styled as a lead automatically.

An ordinary paragraph.

> A pull quote, written as a plain markdown blockquote.

Another paragraph.

layouts/article/single.html renders the hero, the badge, the byline and the body wrapper, so the file holds only what you would actually type. The first paragraph gets the lead treatment and a blockquote gets the pull-quote treatment through element selectors in the stylesheet, so markdown needs no classes.

Jekyll

Identical, in _articles/my-post.md, with layout: article in the front matter. The collection is configured in _config.yml and publishes to /article/<name>.html.

JBake

Content lives under src/main/jbake/content/. JBake accepts markdown with its own header format; follow the shape of the generated article files there.

Plain HTML

There is no engine, so there is no markdown step. Copy an existing article page in html/, change the text, and add a link to it. Or add the article to source/content/articles.json and rebuild, which also updates the other three formats and the news listings.

One caveat worth knowing

The listing pages that index articles (the intelligence feed, the home page news section) are generated from articles.json. A markdown file you add appears at its own URL and is a real page, but it will not automatically appear in those listings. To have it listed as well, add it to articles.json and rebuild. Most people adding an occasional post link to it directly and never need this.

What lives in which file

All paths relative to source/content/.

File	Holds
`site.json`	Company name, tagline, navigation, footer, social links, portal button
`home.json`	Every section of the home page: hero, mandate, pipeline, network, science, partnering, news, contact
`pages.json`	Every interior page: which sections it has, in what order, and their content
`products.json`	The product catalog: names, NDC codes, forms, strengths, categories
`collections.json`	Facilities, partners, and other repeated lists
`articles.json`	News and briefing articles
`ui.json`	Interface labels: column headers, button text, empty states, ARIA strings
`seo.json`	Domain, meta tags, Open Graph, robots policy, schema.org, sitemap, analytics

Design values live one level up in source/tokens/tokens.json: colours, type scale, spacing, radii, shadows and motion. A skin is a small file that overrides a few of them.

Rebuilding

Python 3 only. It ships with macOS and Linux; on Windows it is a free download from python.org. No npm, no package.json, no Sass, nothing to install.

cd source
python3 build-core.py                 # tokens and assets -> dist/
python3 build-site.py                 # content model -> the HTML site

To regenerate the other formats, run the vendor.py inside hugo/, jekyll/ or jbake/. Each one reads the same source/ and rewrites its own files.

A worked example

Changing the company name everywhere:

Open source/content/site.json.
Change "brand" to your company name.
Run the two commands above.
Every page, title tag, Open Graph tag and schema.org block now carries it.

Changing the brand colour:

Open source/tokens/tokens.json.
Change color.brand.primary.
Rebuild. All 36 pages follow, in both light and dark mode.

Choosing a format

Format	Choose it when
HTML	You want a site online today, or you are handing files to a client who will not run a build
Hugo	You want fast rebuilds and a single binary, and you may add many pages later
Jekyll	You are publishing on GitHub Pages, or your team already uses Ruby
JBake	You are in a JVM shop and want the site built by Maven alongside your other artifacts

They produce the same design. Pick on workflow, not on looks.

What is deliberately not included

Astro and WordPress. Not in this release.
A backend. The contact form and portal sign-in are front-end demos. Wire them to your own handler, or point data-endpoint at a form service.
Real content. Every company, person, product, NDC number and figure in the demo is invented. Replace them.

Support: [email protected]. Include the format, the page and what you were doing.