BinWave

endian: little
structures:
  Descriptor:
    fields:
      - {name: name, type: text, length: 16}
      - {name: format, type: u32}
      - {name: byte_width, type: u32}

  Descriptions:
    fields:
      - name: entries
        type: Descriptor
        repeat: {ref: /header.descriptor_count}
    actions:
      - define:              # build a type from the file
          name: Sample
          from: entries
          fields:
            name: {ref: name}
            type:
              ref: format
              cases: {'1': u64, '3': f64, '4': f32, '6': i32}
            length: {ref: byte_width}

  Section:
    fields:
      - {name: id, type: u32}
      - {name: payload_bytes, type: u64}
      - name: payload
        type:
          choose:
            ref: id
            cases: {'1': Descriptions, '2': Samples, '3': Footer}
            otherwise: bytes
        length: {ref: payload_bytes}

YAML: a declarative reader

• Structures describe fields and nested elements, and actions read them, skip or align bytes, calculate values, and choose interpretations.
• References like /header.descriptor_count use earlier decoded values for counts, lengths, and offsets.
• define builds a new record type from descriptions found in the file, and choose picks a type by tag.
• Integers, floats, text, raw byte regions, and calculated values built from what you have already decoded.

from binwave import Field, Struct

FORMATS = {1: "u64", 2: "i64", 3: "f64", 4: "f32", 5: "u32", 6: "i32"}

def sample_type(descriptors):
    fields = []
    for d in descriptors:
        fields.append(Field(d.name.rstrip("\0"), FORMATS[d.format],
                            length=d.byte_width))
    return Struct("Sample", fields, endian="little")

header = file.read_struct("header", Header)
assert header.file_bytes == file.size

for index in range(header.section_count):
    section = file.read_struct(f"section_{index}", SectionHeader)
    end = file.tell() + section.payload_bytes

    if section.id == 1:
        descriptors = file.records("descriptors", Descriptor,
                                   count=header.descriptor_count)
        Sample = sample_type(descriptors)
    elif section.id == 2:
        # registers 31,249,935 records; nothing is read yet
        samples = file.records("samples", Sample,
                               count=header.sample_count)
    file.seek(end)

Discovered 12 fields, 64 bytes per sample
Registered 31,249,935 samples at byte 4,096; values load on demand
Ready: explore in Signal, Samples, Hex, and Structure.

Python: ordinary code, lazy results

• Real Python. Imports, functions, loops, and asserts. The desktop app can use your installed libraries and a selected virtual environment; the web app uses its bundled Python runtime.
• file.read_struct() decodes metadata you can branch on. file.records() registers a typed collection for Plot, Table, and Hex without loading it.
• Field and Struct cover u8–u64, i8–i64, f32, f64, text, bytes, nested structs, counts, offsets, per-field endianness, and expect= checks.
• Scripts see the working bytes, including unsaved hex edits. Edit a byte and the last successful decoder reruns. Stop cancels a runaway loop.