HARPRON Engineering Software BOLD Download BOLD
A HARPRON product

From block diagram to deterministic C code.

Model control logic with blocks, simulate, verify and generate clean C99, with no dynamic allocation and reproducible byte for byte. Built for embedded teams that write everything by hand today.

Version 0.1.0 · Windows · Linux and macOS being validated

FlightControl › Controller ● Valid
Diagram: sensorA and sensorB feed an And block that produces armed; speed is compared with a limit, delayed by pre and combined in an And that produces alarm.
typedef struct { bool armed; bool alarm; } FlightControl_Controller_Outputs;

void FlightControl_Controller_step(FlightControl_Controller_State *self,
        const FlightControl_Controller_Inputs *in,
        FlightControl_Controller_Outputs *out);   /* no malloc, no globals */
80blocks with a normative specification
52language rules, each tied to tests
46diagnostics with stable codes
12scalar types + arrays, structs and enums
0dynamic allocations in the generated C
Features

Modeling, verification and code generation in one environment.

Everything BOLD does today, in a local desktop application. The model is checked on every edit and the generated code is always the same for the same model.

Graphical block modeling

A canvas with block diagram symbols (ANSI/IEEE 91 logic gates, summing circle, gain), editable wire routes and reusable subsystems.

  • Subsystems with instances, each with its own state
  • Local signals, input references, probes and terminators
  • Copy, paste, group, resize, zoom and a diagram map

State machines

A graphical editor for states and transitions with synchronous automata semantics: strong and weak transitions, actions, forks, restart and resume.

  • At most one transition per step
  • Unreachable states detected automatically

Simulation and test scenarios

A built-in reference simulator: run step by step or live, and write test scenarios with oracles, row by row.

  • Expected values for outputs and probes
  • Typed literals: 3, true, [1, 2], {x: 1}

Continuous verification

There is no "verify" button: types, causality, combinational cycles and recursion are checked as you edit, with marks right on the diagram.

  • Diagnostics panel with filters and an explanation of every code
  • Quick fixes when the correction is obvious

Range analysis

Sound interval analysis for integers: points out operations that may overflow, divisors that may be zero and shifts out of range, even through Unit Delay feedback loops.

C99 code generation

One .c/.h pair per subsystem, only <stdint.h> and <stdbool.h>, no compiler extensions and no timestamps.

  • Code preview and export
  • Subsystems implemented in C by the integrator

Activation and iterators

Activate If and Activate When blocks, instances with restart and every, and the map, fold, mapfold and forward iterators.

Modular, Git-friendly projects

A .boldproj project plus one .bold file per library. UTF-8 JSON with canonical key order: the same model always saves the same text, and diffs stay readable.

  • Import other projects as read-only libraries

Strong types, no surprises

bool, char, int8–int64, uint8–uint64, float32, float64, arrays, structures, enumerations and global constants. Operations never mix types: only Numeric Cast converts.

How it works

A traceable generation pipeline, stage by stage.

The core of BOLD is pure TypeScript, separate from the interface. Each stage has a clear responsibility, and the generated C is tested against the simulator.

Model

Project, libraries and subsystem definitions.

.boldproj · .bold

Validation

Structure, types, causality and numeric ranges.

analysis

Dependencies

Instances, execution order and cycles between subsystems.

graph

IR + schedule

A validated intermediate representation with the step schedule.

ir

C99

Intermediate C structure and init/step modules.

cast · codegen
Generated code

C you can read, review and integrate.

The integrating program calls step once per logical step, at the configured period. Nothing more.

  • No global state and no malloc. The state of nested instances lives inside the caller's state.
  • Deterministic. The same model and the same generator version produce the same bytes.
  • Portable. Only <stdint.h> and <stdbool.h>, no compiler extensions.
  • Tested against the simulator. The test suite compiles the generated C and compares it with the reference simulator, exhaustively on 8-bit types.
  • Observable. Probes become fields of the state structure for debugging on the target.
/* FlightControl_Filter.h — generated by BOLD */
#include <stdint.h>
#include <stdbool.h>

/* Confirms a discrete input (true on 3 consecutive steps)
   and reports its rising edge. */
typedef struct {
    bool raw;
} FlightControl_Filter_Inputs;

typedef struct {
    bool clean;
    bool rising;
} FlightControl_Filter_Outputs;

typedef struct {   /* one object per instance */
    /* memory of the pre blocks ... */
} FlightControl_Filter_State;

void FlightControl_Filter_init(FlightControl_Filter_State *self);

void FlightControl_Filter_step(FlightControl_Filter_State *self,
                               const FlightControl_Filter_Inputs *in,
                               FlightControl_Filter_Outputs *out);
Block library

80 blocks, each with a formal definition.

Each block has its output as a function of inputs and state, types, memory, domain, the generated C and examples run by the tests.

&Logic 7 <<Bitwise 6 +Arithmetic 7 √Math 15 sinTrigonometry 7 ⊓Limits 5 >Comparison 6 ?:Selection 2 preTemporal 4 ↑Edges 3 [ ]Arrays 11 { }Structures 4 ●Sources, probes, terminators 3
CodeMessage
BOLD-E011Combinational cycle: the signal depends on itself in the same step
BOLD-E006Recursive use of a subsystem (A → B → A)
BOLD-W012The sum may leave the range of int16
BOLD-W013The divisor may be zero
BOLD-W010State never reached from the initial state
BOLD-W008Subsystem is unused and not marked as root
Quick fixRemove redundant cast · mark as root
Why BOLD

Replace a patchwork of tools with an executable model.

BOLD's competitor is not just another modeling tool. It is the way most small teams work today.

How it is done today

Requirements.docx
Diagrams in draw.io
Hand-written C/C++
Parameter spreadsheets
Tests in Python scripts
Manual documentation, always out of date
→

With BOLD

Executable model
▼
Simulation and test scenarios
▼
Continuous verification and range analysis
▼
Generated, deterministic C99
▼
C tested against the simulator
Plans

BOLD is free. Even at your company.

No block limit, no students-only restriction. Companies that need more pay for infrastructure, support and assurance.

Coming soon

BOLD Enterprise

On request

For organizations that need control, collaboration and support.

  • HARPRON support with SLA
  • LTS versions with a frozen toolchain
  • Private libraries and templates
  • Company modeling rules
  • SSO, permissions and audit
Talk to HARPRON
Coming soon

BOLD Assurance

On request

For programs that need verification evidence and qualification.

  • Evidence for DO-178C / DO-331
  • ISO 26262 and IEC 61508
  • Tool qualification kit
  • Reproducible, archived builds
Talk to HARPRON
What's next

From modeling tool to development platform.

BOLD Desktop stays free and local. Around it, HARPRON is building:

BOLD Cloud Planned

Shared projects and requirements, model reviews, semantic diff, verification history, traceability and CI/CD.

BOLD AI Planned

A modeling assistant, with the option to use your own API key or a local model.

BOLD Hub Planned

A marketplace of block libraries: communication interfaces, BMS, avionics and community components.

Command line Planned

Validation and code generation in your continuous integration pipeline.

Linux and macOS Being validated

AppImage, deb and dmg packages, declared after verification on each system.

Qualification Planned

A path to use in critical systems, with evidence per standard.

Download BOLD. Use it at your company. It costs nothing.

Open the FlightControl example project from File › Open Example Project and generate your first C code in minutes.

Windows · available Linux · being validated macOS · being validated