Stop rebuilding workload generators for every new platform.
FLOW generates varied, constraint-aware instruction sequences for virtual prototyping, SoC simulation, and performance analysis. Describe your architecture and address space — FLOW handles operand legality, constraint enforcement, and reproducibility. Any ISA. Any simulator.
Write what you want to run in a small .flow script.
Describe your ISA in YAML or as a compiled plugin.
FLOW handles legal operand selection, constraint enforcement,
and reproducible random draws — your ISA definition never needs to change.
Every new architecture or platform variant starts the same way: the model is ready, but the workload generator isn’t. Hand-writing sequences is slow, error-prone, and doesn’t scale. A new SoC spin shouldn’t mean rebuilding the stimulus from scratch.
FLOW ends that cold-start.
scene load_stress {
random 32
tags: [mem]
}
random draws
constraint solve
register alloc
RNG (seeded)
LW r3, r0, 16
SW r4, r5, 8
LH r7, r3, 4
LBU r2, r1, 0
FLOW never hard-codes mnemonics, register counts, or encoding rules. Every ISA detail arrives at runtime through a plugin — the same engine runs your custom VLIW, fixed-width, or proprietary microcontroller ISA without recompilation. No engine build from source required.
Pass --seed and get the exact same stream every time,
across machines and runs. Determinism is enforced at the engine level
— plugins cannot introduce hidden randomness.
Bit-identical output in CI, by design.
Most teams do — until the ISA changes, a new SoC variant ships, or the stimulus needs to cover an edge case that hand-written sequences never reach. FLOW makes the right thing easy and the fragile thing unnecessary.
.flow says what, the engine decides howrandom 32 tags:[mem, load]--seed 42 — bit-identical output on any machine, any engineerFLOW assembly output connects directly to the simulators, assemblers, and virtual platforms you already use — no adapters, no glue scripts.
Describe any fixed- or variable-width ISA in YAML or C++. Base ISA and extensions coexist in the same plugin. Under an hour to a working Tier‑A plugin.
FLOW connects directly to your virtual platform’s stimulus path. Encoded byte streams ready for TLM-2 consumption — no assembler step, no post-processing, no glue code.
Describe your platform’s address space alongside your ISA — FLOW generates load and store sequences that stay within valid regions. Realistic traffic for cache, interconnect, and power analysis, not just instruction-fetch patterns.
FLOW emits standard assembly text. Run your toolchain assembler, link with a minimal runtime, and execute on the target — real silicon or model alike.
Pass --seed and every run produces the exact same stream.
Deterministic output is enforced at the engine level.
Diff your golden output — FLOW’s output never drifts.
No ISA knowledge is baked into the engine. VLIW, DSP, and proprietary microcontroller ISAs are first-class citizens through the same plugin API.
A .flow script expresses simulation intent, not ISA mechanics.
Scenes, loops, and inline directives compose naturally.
The engine handles constraint solving, register allocation, and random draws
— your script stays readable when the ISA changes.
A scene is a named, reusable sequence of instructions.
Scripts compose scenes, loops, and inline directives —
the same scene works across any ISA that exposes matching tags.
A .rules file defines the envelope: reserved registers,
global instruction-mix ratios, and locked constraints.
Scripts inherit the envelope and cannot violate it.
Four integration tiers, ordered by the C++ you must write. Begin at the lowest tier that covers your ISA; move up only when you need more control. Most ISAs start and stay at Tier A.
Describe your ISA entirely in instructions.yml and
registers.yml. No compilation needed.
Under an hour to running output.
Add a small encoding step for split immediates, PC-relative targets, or packed fields. Same YAML base; roughly one C++ source file.
Add cross-operand validation for register write-protection, pipeline hazard rules, or instruction pairing constraints.
Complete control over every aspect of your ISA — exotic encodings, instruction side effects, and grammar extensions. For the architectures that need it all.
Place two YAML files in a directory and point FLOW at it. No compiler, no build step. The fastest path to running output.
ⓘ Both files must follow the FLOW YAML schema —
see sdk/docs/yaml-plugin.md in the SDK for the full field reference.
Build your ISA as a shared library with the provided CMake helper, then load it at runtime. No engine rebuild required.
Write the instruction table, register file, and optional encoding hooks. Your plugin is entirely your own work under MIT headers — no engine license obligations.
Define the constraint envelope: reserved registers, global instruction mix ratios, and locked constraints that apply across all scripts for a given simulation campaign.
Express simulation intent through directed sequences, constrained-random draws, loops, and scenes — without touching the ISA definition or the constraint envelope.
Both flow and flow_validate are single-binary tools.
No runtime dependencies beyond the ISA plugin you supply.
| Option | Description |
|---|---|
| --plugin <path> | Load a compiled ISA plugin (.so / .dll) |
| --isa-dir <path> | Load a pure-YAML ISA from a directory (instructions.yml + registers.yml required) |
| --isa <name> | Override ISA name (default: taken from script or YAML) |
| --seed <n> | Fix the RNG seed for reproducible, bit-identical output |
| --count <n> | Number of instruction sequences to generate |
| --output <file> | Write output to file (default: stdout) |
| --help | Print usage |
--plugin and --isa-dir are mutually exclusive;
--plugin takes precedence when both are given.
The FLOW engine binary is proprietary and covered by a separate binary license included in every release archive. The engine source is not distributed.