Vada Language

Vada is the hackable data composition language built for creating, validating, and transforming data artifacts.

Under construction. Heavy construction.

Focused, Yet Flexible

Vada exists to solve a very specific set of problems for the video game industry:

Building binary data artifacts from hierarchical archives containing thousands of heterogenous entity records.
Handling the incremental evolution of record schemas throughout the lifetime of a project.
Ensuring consistent data constraints in ways that offer clear and immediate feedback for both designers and developers.

That means that Vada is built to handle complex and diverse data sets at scale and over time in ways that facilitate cross-disciplinary collaboration.

Vada isn't just YAML with functions and imports, or a serialization format with some extra bells and whistles.

Vada is an ecosystem for building data artifacts that can handle everything from entity record collections to dynamic configuration management.

simple_example.va math.va control_flow.va

@module: PersonData

--- @Imports:
@std::util::$.[$utilSchema]

--- @Local:
$edType: "None" | "Highschool" | "Undergraduate" | "Graduate"
$desc_string: !str & != ""

--- @Public:
$personSchema: $utilSchema & {
    @Doc::short: "A basic structure for person data"
    --- Basic:
    name: $desc_string
    age: !int & > 0
    address: @Local::$addrStruct | @None // Words!

    --- Experience:
    employer: (!str & != "") | @None
    education: [($edType, $desc_string), ...]
    certs: [!str & != "", ...] | @None

    #score: certs->#reduce(@sum)
        + education->#reduce: + _ ?>
            "None" ?> 0;
            "Highschool" ?> 1;
            "Undergraduate" ?> 4;
            "Graduate" ?> 6
}

@assert: 1 + 2 == 3
@assert: 4 - 1 == 3
@assert: 2 * 2 == 4
@assert: 4 / 2 == 2.0
@assert: 4 % 2 == 0
@assert: 4 ^ 2 == 16
@assert: 1 .> 2 == 4 // MATH
@assert: @math::pi * 2 == @math::tau

// TODO: Update this
$boundFac: !dec::float(@prec: 4) & 0..=1
$someFlag: !flagset: 
    @repr !int32;
    red    = 2 .> 0,
    green  = 2 .> 1,
    yellow = 2 .> 2,
    blue   = 2 .> 3,

Another Placeholder

Topologically Empowered

Vada uses patterns of parallel construction and topological semantics in order to add layers of accessibility on top of complex data structures.

Records are comprised of both fields and sections, with the latter providing query-like accessors that enable abstract topological traversals and transforms.

Sections add semantics without forcing hierarchy, enabling the construction of parallel access patterns across the topology of an archive.

Sections also serve to intelligently handle the propagation of types and records, both downwards into sub-modules and upwards into manifests, using parallel construction to prevent cyclical imports.

simple_example.va math.va control_flow.va

@module: PersonData

--- @Imports:
@std::util::$.[$utilSchema]

--- @Local:
$edType: "None" | "Highschool" | "Undergraduate" | "Graduate"
$desc_string: !str & != ""

--- @Public:
$personSchema: $utilSchema & {
    @Doc::short: "A basic structure for person data"
    --- Basic:
    name: $desc_string
    age: !int & > 0
    address: @Local::$addrStruct | @None // Words!

    --- Experience:
    employer: (!str & != "") | @None
    education: [($edType, $desc_string), ...]
    certs: [!str & != "", ...] | @None

    #score: certs->#reduce(@sum)
        + education->#reduce: + _ ?>
            "None" ?> 0;
            "Highschool" ?> 1;
            "Undergraduate" ?> 4;
            "Graduate" ?> 6
}

@assert: 1 + 2 == 3
@assert: 4 - 1 == 3
@assert: 2 * 2 == 4
@assert: 4 / 2 == 2.0
@assert: 4 % 2 == 0
@assert: 4 ^ 2 == 16
@assert: 1 .> 2 == 4 // MATH
@assert: @math::pi * 2 == @math::tau

// TODO: Update this
$boundFac: !dec::float(@prec: 4) & 0..=1
$someFlag: !flagset: 
    @repr !int32;
    red    = 2 .> 0,
    green  = 2 .> 1,
    yellow = 2 .> 2,
    blue   = 2 .> 3,

Another Placeholder

Functionally Inspired

Vada's Expression syntax focuses on array math and function chaining, using pipe operators to form readable lambda sequences without excessive parentheses.

Taking inspiration from CUE, Vada features a diverse set of unary prefix comparators, allowing for concise constraint expressions. When combined with Vada's Rust-like range expressions and inline control flow, these operators enable nuanced polymorphism without relying on hierarchical inheritance.

Vada's vector and matrix syntax borrows from MATLAB, with semicolon-separated columns and concise symbolic operators for inversion and transposition.

simple_example.va math.va control_flow.va

@module: PersonData

--- @Imports:
@std::util::$.[$utilSchema]

--- @Local:
$edType: "None" | "Highschool" | "Undergraduate" | "Graduate"
$desc_string: !str & != ""

--- @Public:
$personSchema: $utilSchema & {
    @Doc::short: "A basic structure for person data"
    --- Basic:
    name: $desc_string
    age: !int & > 0
    address: @Local::$addrStruct | @None // Words!

    --- Experience:
    employer: (!str & != "") | @None
    education: [($edType, $desc_string), ...]
    certs: [!str & != "", ...] | @None

    #score: certs->#reduce(@sum)
        + education->#reduce: + _ ?>
            "None" ?> 0;
            "Highschool" ?> 1;
            "Undergraduate" ?> 4;
            "Graduate" ?> 6
}

@assert: 1 + 2 == 3
@assert: 4 - 1 == 3
@assert: 2 * 2 == 4
@assert: 4 / 2 == 2.0
@assert: 4 % 2 == 0
@assert: 4 ^ 2 == 16
@assert: 1 .> 2 == 4 // MATH
@assert: @math::pi * 2 == @math::tau

// TODO: Update this
$boundFac: !dec::float(@prec: 4) & 0..=1
$someFlag: !flagset: 
    @repr !int32;
    red    = 2 .> 0,
    green  = 2 .> 1,
    yellow = 2 .> 2,
    blue   = 2 .> 3,

Another Placeholder