sci-core is live

sci-core is the scientific module on SlickFast. It’s not a new product — eight scientific chart types on the same deterministic engine as everything else, called the same way, priced at zero. Same rule as always: a JSON spec is the picture, byte for byte, forever, and the hash is on the page.

8 chart types — from scatter to volcano. Real log axes, including base-2 for doubling data. $0 — free. Soft launch, callable like any other type.

What’s actually built — all eight types

• scatter — x/y points, linear or log
• errorbar — scatter with y-error whiskers
• lineplot — connected growth curves or spectra
• barplot — categories × values, optional errors, log-y
• survival — Kaplan–Meier, computed from raw times + censoring
• blandaltman — method agreement (bias + limits)
• qq — normal Q–Q
• volcano — fold-change + p-value in; the `−log₁₀(p)` transform and class coloring happen in-engine

Scales: `linear`, `semilog-x`, `semilog-y`, `loglog`, `log` — plus `logBase: 2` for anything that moves in doublings. Fits, error bands, reference lines, and peaks wherever a type supports them.

Not built: boxplot and histogram. They’re on the roadmap, not in the tree. Don’t claim them yet.

Raw numbers in. Publication-shaped plot out.

The difference between this and a normal chart tool is where the statistics happen.

Every other chart service says: compute your results, then we’ll draw them. SlickFast says: give us the raw data and we’ll compute Kaplan–Meier survival curves, Bland–Altman agreement plots, Q–Q distributions, and volcano plots — then render them deterministically. A lab tech dumps raw values in one call and gets a publication-grade plot back. No R. No Python. No notebook.

To be precise about the boundary, because it matters to the people who’ll check: these are plot-supporting statistics. This isn’t a general statistics engine — no regressions, no hypothesis tests, and no p-value computation (the volcano plot takes p-values in and transforms them). The honest claim is stronger than the inflated one: your plotting pipeline disappears.

The log axes are real — and the furniture is the product

Scientists don’t read the color palette. They read the axis. What makes a chart “look log” is the furniture: the `10ⁿ` decade labels and the way the 2–9× ticks bunch up inside each decade. That’s the first thing a skeptical reviewer notices, and it’s built in.

For biology specifically, there’s base-2. Nature doubles — bacteria divide, cell populations span hundreds to millions, gene expression is measured in 2×, 4×, 8× fold-changes. On a standard base-10 axis those land on a sparse tick at 1, 10, 100 — and a culture that doubled eight times looks like a flat, meaningless slope.

`logBase: 2` fixes it: every doubling gets its own rung. Eight doublings, eight visible steps. You can count generations by counting rungs. Labels default to plain numbers — 100, 200, 400, 800 — because that’s what makes the doubling feel real (superscript `2ⁿ` is available too). R and Python can do this, but you hand-configure the tick formatting yourself. Here it’s five characters in a spec.

The engine has opinions — and that’s the point

Most chart tools render whatever you hand them, garbage included. sci-core doesn’t.

• Ask for base-3 and it doesn’t silently fail — it tells you what is supported.
• Put a logBase on linear data and it doesn’t draw nonsense — it tells you to set a scale first.
• Try more than 24 doublings and it doesn’t produce an unreadable hundred-tick axis — it steers you to base-10, where that range makes sense.

In a scientific context, a bad chart can become a wrong conclusion. This is integrity built into the tool, not a convenience feature.

Audited, not just asserted

The in-engine math ships with a correctness record you can check, not a claim you have to trust: 26 checks, 26 green, zero dependencies. Every reference is a published constant or hand-computed exact arithmetic.

• Bland–Altman is byte-exact — bias and both limits of agreement match hand-worked math, down to the rendered label characters.
• Kaplan–Meier passes the nasty edge case — where S(t) lands exactly on 0.5 and the median needs the standard `≤` convention to answer 2 instead of 3. That’s the case that quietly breaks naive implementations.
• The Q–Q probit hits a max error of 4.36×10⁻⁷ across seven published anchors — a serious approximation, not a weekend one.
• The Q–Q position convention is declared in code (Hazen), so “different from R” is documented, never a surprise.

The rule going forward: no scientific type ships without a verification case. Boxplot and histogram will get theirs the moment they exist.

Why the log axis matters — one picture, two views

E. coli going from 120 to 71,000 CFU/mL. On a linear y-axis, the first hour disappears into the floor. Flip to log-y and every decade gets its own floor — the early growth becomes visible.

Same data. One toggle in the spec.

The twin, and why it changes reproducibility

Every SlickFast Page has a twin: add `.json` to the URL and you get the exact spec that produced it — same fingerprint, same bytes.

For science, that means a figure isn’t just a picture. It carries its own source. Any chart in a paper, a lab notebook, or a regulatory submission can be regenerated exactly, forever. An in-house matplotlib script can’t promise that; it can only point at whatever code existed when someone remembered to save it.

See it live:

• sci-core — Night lab — the permanent showcase
• its twin — same URL, plus `.json`
• Paper demo — raw input through the harness

How to call it

1. `describe_type({ type: "volcano" })` — or `scatter`, `survival`, any of the eight

2. `render_chart` with that type and the shape the contract returns

3. Prefer `format: "svg"` when the host paints artifacts

4. For a full document: `render_page` / `publish_page`

The data shapes differ from the gallery types — these take x/y series, not only labels + values — so call `describe_type` first. The sci types are not in the 47-chart gallery board.

Local MCP draws without a key. A public URL needs an SF- key — News #10 and News #11.

Takeaways (humans)

1. sci-core is free — eight scientific types, same engine, nothing to buy.

2. The log axes are real — proper `10ⁿ` ticks, decade bunching, and base-2 for doubling data. Not a visual stretch.

3. Open the twin — add `.json` to any Page URL and check the math yourself.

Takeaways (agents)

1. Sci types are callable on `render_chart` / `describe_type`: scatter, errorbar, lineplot, barplot, survival, blandaltman, qq, volcano.

2. They’re not in the 47 gallery board — `describe_type` first; data shapes differ.

3. Do not invent boxplot or histogram. They don’t exist yet.

4. Cold path stays: `get_started` → `news` → `describe_type` → `render_chart`.

5. Soft launch — the module is live, but it’s not a separate product. Don’t pitch it as one.

One sentence to steal

Scientific charts. Same engine. Same bytes. Free.

Night lab · Get started · News · Archive