One workbench.Two faces. One truth.
Janus takes the most fragile part of running a model (the environment, the toolchain, the “which version on whose machine”) and reduces it to a single choice: which container do you want to run in?
The environment is a choice,
not a chore.
For most teams the modeling environment is the quiet source of nearly every slow afternoon. A library mismatch. A path that's right on one machine and wrong on the next. Janus seals the engine, its dependencies, and its exact configuration into a versioned, portable container.
Pick a container. That's the whole job.
Run a model by selecting it and pressing go. Change engine versions by selecting a different container. No reinstall, no PATH surgery, no “works on my machine.”
Get the same result everywhere. The container is the single source of truth for the environment, so a run on a laptop and a run on the cluster are the same run, down to the image fingerprint recorded in the log.
The container runs sealed: inputs handed in, results handed back, license files supplied at runtime and never left behind on disk. Reproducible and clean.
7.5
7.4
·tt
Two faces, one tool.
Janus was built for two audiences who rarely get served by the same tool: the modeler who just wants the job to run, and the IT & QA professionals who need to prove exactly how it ran.
You came to build models,
not babysit infrastructure.
Open a model, choose where it runs, press go. Output streams back live as it executes.
Load and run
NONMEM is the primary target and behaves exactly the way you're used to: control streams in,
.lstand the usual output out, run in place.It already knows your engine
Janus recognizes the engine from the model file itself. No telling it what you're running.
Run anywhere, unchanged
The same model goes to your laptop, an HPC grid, or an isolated container. Just a different selection.
Never lose a run again
Every execution is captured (command, result, outputs, environment) and stored right alongside the model. Your history travels with your work.
You're accountable for what
the modelers can't see.
Consistency, traceability, and the ability to prove it to an auditor.
Qualify it yourselves
Built-in IQ/OQ runs a known reference model, confirms the answer within tolerance, and writes a timestamped, retained report for the binder. No vendor visit.
Every run is signed
Execution records are cryptographically signed by the person who ran them, with identity and a verifiable fingerprint attached. Genuine and unaltered, provably.
Auditable down to the image
The exact engine and configuration used for any result is recorded — not described, recorded.
Deploy on your terms
It works offline. No monthly phone-home to validate a license. Airgapped and tightly controlled networks are first-class, not an exception.
You shouldn't have to tell a tool what you just handed it.
Point Janus at a model and it inspects the file (both the kind of file it is and what's written inside) and recognizes the engine behind it.
The container layer underneath can run essentially any binary. The intelligence about which engine a model needs lives in Janus's orchestration on top. That's what leaves room for more engines, Stan and Torsten among them, to follow without re-architecting anything.
$PROBLEM … $SUBROUTINES: NONMEM
Reproducibility you can hand to an auditor.
Every execution is captured automatically and stored alongside the model. Each record is cryptographically signed by whoever ran it, with identity and a verifiable fingerprint attached, so you can prove a record is genuine and unaltered after the fact.
Janus produces the execution journal (what ran, how, and by whom) while your systems of record stay validated and under your control. A tool that strengthens your quality process, not one that asks you to hand it over.
Local, grid, or container:
your choice at the moment you press go.
The tool adapts to where your compute lives instead of forcing your work to move. Grid scheduling speaks SLURM and SGE; jobs, nodes, and status come back into the same window.
Your own machine
Run NONMEM in place on the laptop in front of you. Synchronous or parallel, output streaming live.
HPC scheduling
Submit to SLURM or SGE with nodes, CPUs, memory and queue presets, without leaving Janus.
Sealed & reproducible
An isolated container where the environment itself is pinned to an image fingerprint.
Built to operate
in a vacuum.
Once you provide a license, Janus runs sealed off from the world. No mandatory connection. No metering in the background. No monthly phone-home to validate a license. Airgapped and tightly controlled networks are first-class, not an exception you have to fight for.
No calls home
Zero outbound telemetry, zero license check-ins. What runs on the machine stays on the machine. Verifiable on your own network monitors.
Self-contained, self-expiring licenses
The license carries its own validity. It activates offline and expires on its own terms. No server to call, nothing to renew over the wire.
Runs in isolation, indefinitely
Drop Janus behind an airgap and it keeps working (modeling, signing, qualifying) with no dependency on the outside world.
Complexity collapses
to a selection.
The environment is a dropdown
The single most error-prone part of modeling, the runtime, becomes a selection. That's the whole thesis; everything else follows.
One workflow, three places
Local, grid, or container: the same model, the same steps, decided at the moment you press go.
It infers the engine
Janus reads the model and recognizes the engine, so the right one isn't a setting you maintain; it's something the tool works out.
Audit-ready by default
Signed run logs, retained qualification reports, container-pinned environments. “It reproduces” becomes a thing you demonstrate.
Self-service qualification
Teams qualify their own installations on their own hardware, on their own schedule. Built in, not billed by the hour.
Genuinely cross-platform
One native application across Windows, macOS, and Linux: the laptop and the validation server run the same thing.
Step up only when you need
what the next tier adds.
Each tier includes everything in the one before it.
- Local NONMEM execution
- Engine auto-recognition
- Live streaming output
- Cross-platform desktop app
- Everything in Basic
- Grid scheduling (SLURM & SGE)
- Signed, tamper-evident run log
- Embedded output files & export
- Everything in Advanced
- Container orchestration
- Switch engines by image
- Built-in IQ/OQ qualification
Pick a container.
Run your model.
Keep the receipts.
Janus stands at the threshold between the science and the system that has to trust it. The container is the bridge: one choice that makes a job easy to run and easy to prove.