Skip to content

Change Log



  • Fixed bug in the XML-to-TethysL translator: For the Call case, the PriorityHere attribute was not retained. Thanks, Yanwu, for reporting.



  • The version has been updated to 4.0.0 to reflect the significant improvements and new features implemented over the past few months.
  • Embedded LRAUV definitions as of Fri May 24 10:10:20 2024 -0700 (commit 7f87fec24).



  • Nested macros are supported, so the interim "partially supported" warning diagnostic has been removed.



  • Maintenance release with embedded LRAUV definitions as of Fri May 10 11:28:16 2024 -0700 (lrauv-application commit a134c88d686).


    As a reminder, you can still instruct TethysL to use any updated LRAUV definitions, for example, by providing the LRAUV Revision setting in the VSCode extension, or using the --lrauv-revision option in the CLI program, or pointing it to the location of your lrauv-application clone.



  • Maintenance release with embedded LRAUV definitions as of Apr 23 16:15:17 2024 -0700. (lrauv-application commit 3837c7def96).



  • Comments right after the expression associated with argument or output definition were lost in translation from TethysL to XML. This issue has been fixed. NOTE: However, we do not intend to capture all possible cases because such comments are really only relevant at the source level, which is the TethysL script.



  • Multiple same-name array definitions are now explicitly disallowed. While such feature has not been used in actual mission scripts, the necessary support was still incomplete, having some non-trivial aspects unresolved.

    For example, if exercising the go-to-definition feature in VS Code for a reference like Depth[$j] in the body of a macro (see assign line below), it is not clear which definition to navigate to.

    Example of what is now disallowed:

    arguments {
      Depth[1..5] = 3 meter
      Depth[6..10] = NaN meter
    macro $j = 1..10 {
      aggregate aggr$j {
        run in sequence
        assign in sequence Depth[$j] = 42 meter
    The second Depth argument definition would now be flagged as a "duplicate" error.

    However, one can still get the same effect by using the multiple initialization mechanism:

    arguments {
      Depth[1..10] = {
        1..5: 3 meter,
        6..10: NaN meter
    macro $j = 1..10 {
      aggregate aggr$j {
        run in sequence
        assign in sequence Depth[$j] = 42 meter
    Note that in this case there's no ambiguity when using the go-to-definition feature.

    One difference in syntax, though, is that there's only one possible ("template") description associated with all expanded elements, not one for each sub-range.



  • Embedded LRAUV definitions as of Mar 27 14:25:22 2024 -0700 (lrauv-application commit 323225a8a6723).
  • Formatter: Fixed a regression involving the formatting of break if followed by a timeout, where the timeout statement would get increasingly indented with each formatting operation.



  • More precise error message for when there is an index range overlap in the definition of array arguments or outputs having the same base name. For example, for:

    arguments {
      Depth[1..5] = 3 meter
      Depth[2..10] = NaN meter
    the error message will indicate a duplicate definition along with the specific overlapping range (in this case, 2, 3, 4, 5).

  • Recent changes in inserted XML scripts (addition of a copyright header) caused their loading to fail from the parent .tl file, which exposed an array index out of bounds exception in the TethysL parser. This has been fixed.



  • Fixes an issue that prevented the Dash from listing the Lat/Lon parameters of a mission in the desired order Lat1, Lon1, Lat2, Lon2, etc., when such parameters are defined in the mission via arrays (e.g., Lat[1..10], Lon[1..10]).



  • Nested macros are now supported. Example:

    mission {
      arguments {
        Lat[1..7] = NaN degree
        Lon[1..7] = NaN degree
      # ...
      macro $j = 1..5 {
        aggregate Leg$j {
          run in sequence
          # ...
          macro $k = 1..7 {
            aggregate Wpt$k {
              run in sequence
              behavior Guidance:Waypoint {
                run in sequence
                set latitude = Lat[$k]
                set longitude = Lon[$k]


    • A nested macro will generate a warning diagnostic during validation while the feature is more tested, including the C++ counterpart on the LRAUV side.
    • The use of a macro variable (e.g., $k above) is only resolved against the immediately enclosing macro.



  • Fixes #35 "Incorrect duplicate ID errors in macro". Having aggregate elements (e.g., Wpt1 and Wpt2 below) within a macro aggregate (Leg$j) was not handled properly thus causing spurious duplicate ID errors.


    mission {
      macro $j = 1..5 {
        aggregate Leg$j {
          run in sequence
          aggregate Wpt1 { ... }
          aggregate Wpt2 { ... }
    Thanks, Quinn, for reporting.



  • A fix in the handling of the value entered for the LRAUV Revision setting in the VSCode extension such that it is consistent with how the LRAUV definitions get published. The issue was related with git branch names containing slashes (e.g., release/March-act-ii-Brute).

    Similar adjustment for the CLI --lrauv-revision option.


  • Maintenance release with updated embedded LRAUV definitions (to reflect latest state of lrauv-application).


  • VSCode extension:
    • Now the Express migration and Reformat XML & TX and compare commands do not include namespace declarations when reformatting the generated and original XMLs to avoid unnecessary diffs.
    • New command Reformat XML file (ignore namespace declarations), similar to Reformat XML file but without including namespace declarations in the reformatted XML.
    • More ad hoc adjustments in xml reformatting to facilitate visual inspection.


  • The name duplication of an argument or output definition is now always a compile error, no matter if it is an array or not. This was already the case for non-array definitions, but not for the possible combination of arrays and non-arrays. For example, this was previously accepted:

    arguments {
      CartridgeType[1..60] = -6 count
    output {
      CartridgeType = -6 count
    basically because CartridgeType is different from the names that get expanded from the array definition: CartridgeType1, CartridgeType2, etc. While the underlying validation logic could be expanded to accommodate the initial intent, the simple solution is just to be more restrictive without sacrificing any real use case. The case above can be fixed by just renaming one of the elements, for example:
    arguments {
      CartridgeTypeArg[1..60] = -6 count
    output {
      CartridgeType = -6 count

  • CLI: New --all option for the compile command to compile all .tl files under the given --mission-dir.


  • VSCode extension: The Reformat XML & TX and compare command now creates a separate file with the reformatted XML (i.e., original file is unchanged). The diff panel will then be between SomeMission_REFORMATTED.xml and SomeMission.tx. (Note that the Express migration command also involves calling Reformat XML & TX and compare.) Even though the original SomeMission.xml is eventually to be removed, this new approach is intended to avoid risk of regenerating the from a modified XML.


  • XML-to-Tethysl: To further facilitate migrations, the following auto-adjustments were added for "faulty" <Aggregate>s, depending on whether they have an explicit execution mode or not:

    • No execution mode at all: run in sequence is inserted;
    • Only one execution mode (the normal situation): keep it; no adjustments;
    • Multiple execution modes: If any When or While are present, keep only those (the assumption is that any of those is the intended one). Otherwise, keep all the others. In both cases, not trying any further adjustments: any multiple execution modes that remain will be reported as errors anyway.

    NOTE: the above performed for the resulting TL, not on the XML.

    Couple of faulty aggregate examples as seen at time of writing:

    No execution mode:

      <Aggregate Id="SyslogWpMaxDistanceReachedSalt">
            <Not><Arg Name="PeakDetectSalinity"/><And><Arg Name="PatchPeakSalinity"/><Ge><Units:psu/><Value>0.0</Value></Ge></And></Not>
    Multiple execution modes:
    <Aggregate Id="MissionStartComms">
            <Arg Name="CommsAtMissionStart"/>
            <And><Not><Arg Name="MissionStartCommsCompleted"/></Not></And>

  • XML-to-Tethysl: A fix in the left-parenthesization of multiple-operator expressions to preserve the evaluation order as performed by the LRAUV framework.


  • VSCode extension: fixed regression where navigation to defs/refs got broken when dealing with lrauv-application as workspace.

  • Lexer: Leading . for a number is now invalid, e.g., write 0.5 instead of .5.


  • tl-to-xml: replace \n to &#x0A; in syslog string fragments.


    syslog important "\n      NeedComms Timeout Surfacing\n    "
    now translated to:
    <Syslog Severity="Important">&#x0A;      NeedComms Timeout Surfacing&#x0A;    </Syslog>
    previously, incorrectly translated to (affecting the contents of the string fragment):
    <Syslog Severity="Important">
          NeedComms Timeout Surfacing


  • Linter: Removed the "Inconsistent top-level ID" diagnostic as it is now OK to indicate any (explicit) ID.


  • The "Conflicting variable definition" diagnostic is now a warning, not an error.

    With Science/trackPatchOil as an example, the diagnostic is as follows at the point of the insert Insert/ statement:

    Conflicting variable definition: Different base unit for `PatchOil`:
    it is kilogram_per_cubic_meter (for microgram_per_liter) in current file,
    and kilogram_per_kilogram (for practical_salinity_unit) in inserted file.

    That is:

    • PatchOil is defined in both Science/trackPatchOil and Insert/
    • Those two definitions have different base units.
    • This was considered an error.
    • However, the mere insertion should not consider that situation as an error, as the two variables belong to different namespaces.
    • Of course, it continues to be an error if the two variables are explicitly combined in some incompatible way (as illustrated below)

    As displayed by VS Code, the following snippet shows the mentioned diagnostic, now as a warning, as well as two associated errors intentionally entered to illustrate the point of incorrect combination:


  • The "Redundant top-level ID" warning has been disabled. This mainly to avoid the rather "noisy" compile output given the several missions currently affected. Note that this diagnostic is still in place via the linting feature.
  • *IF.h header parser updated to accommodate adjustments in the lrauv-application codebase.


  • VSCode extension enhancements:
    • Improved completions for what goes right after outputArg, that is, to indicate list of possible output parameters.
    • Fixed completions for what goes after run in
    • Improved Universal: related completions.
  • Language:
    • Simplified the assign and touch constructs by removing their block options. Except for (written by us tethysl devs) that feature was not used in real scripts. The simplification also facilitates the implementation of the tethysl parser for the LRAUV in C++.
  • Prettifier:
    • In some cases, multiple empty lines in between tokens were not condensed as expected.



  • Embedded LRAUV resources as of lrauv-application@0305d06f5cdd with merged release/dOcktoberFest.
  • Removed the "Inconsistent top-level ID" warning: As of lrauv-application@91df40131 the LRAUV now reports the mission id as part of the "Loaded" logImportant message, so no need to complain about such id being inconsistent with the filename.
  • Other adjustments and fixes
    • Escaped \" in syslog string now properly handled when reformatting
    • Any < or > in syslog string now properly escaped in the xml result
    • Adjusted message for ConflictingVariableDefinition



  • To further streamline the migrations from XML, there's a new "Express migration" VSCode command, which performs generation of, reformatting, and diffing, in one step. This is part of the general migration process, which is described in the Migrating from XML section.

    Thanks, Quinn, for the great suggestion!



  • A fix in the xml-to-tl translation: Any comments occurring right before a closing tag in the XML were not translated into the .tl result. Example:

    <Aggregate Id="UpdateCenter">
        <Assign><Sequence/><Arg Name="Lon"/><CustomUri Uri="_.Lon"/></Assign>
        <!-- these comments were lost -->
        <!-- but are now translated. -->
    Thanks, Quinn, for reporting!



  • VSCode extension enhancements:

    • This version introduces dispatch of semantic tokens. This means that certain identifiers are now highlighted differently according to their specific role. This includes arguments, outputs, inserts, module behaviors, and behavior settings. Note that actual displayed styling depends on your selected "theme" in VSCode.

    • The "Outline" view now includes all first-level elements in the script.

    • Fix: navigation to argument/output references was not working when script has semantic errors.

  • Markdown documentation generation: The contents of """...""" descriptions are now processed to avoid possible conflict with surrounding Markdown in the generated pages. In concrete, any heading indicator (#, ##, ...) is now increased by 3 levels (otherwise, they would affect page elements like the table of contents).

    If there's a need to disable the Markdown dispatch for a description, just use """!) as the opening delimiter. The contents will be wrapped in a triple-backtick block in the generated page.

  • Fixed resolution of arguments/outputs in inserted mission or aggregate with no explicit ID.

  • (Internal) Significant code cleanup.



  • Updated tethysl library for TethysDash, with fixed description of boolean arguments (so, they now include the bool unit, even if only defined with literal value).



  • CLI:
    • The lrauv-info command has been renamed to show-lrauv-info.
    • The validate-xml command has been removed.
  • The tethysl library for TethysDash has been updated with appropriate handling of the now optional top level ID in .tl scripts.



  • Language fix: As traditionally allowed by the Tethys schema but that was missing in TethysL, the when condition construct can optionally be followed by repeat = value (to cause the associated behavior to run the specified number of times after the when condition becomes true). Example:

    run when ( Depth > DepthBase ) repeat=3

    The when condition is documented here. Thanks, Mike G., for the heads-up and documentation.

  • Markdown page generation (used for the documentation site): The used behaviors section for each mission page is now titled "Invoked Module Behaviors" to better reflect the fact that the listed items are module behaviors. Example here.

  • Some adjustments in the reports generated by the check-format-all and lint commands.



  • Compiler: Now both inserts and aggregates (including those expanded from macros) are checked for possible ID duplication within the same block. A perhaps contrived but illustrative example where an explicit ID is given to avoid duplication:

    insert Insert/
    insert id="otherScience" Insert/
  • VSCode extension fix: The list of completions for possible ID in a call refId=... now also includes aggregates (previously, only inserts).


    The completion list still needs to be restricted to the actual valid IDs, but the subsequent validation will still report any invalid ID.

  • Fix in CLI: The lint command now works when no --mission-dir is given.



  • Language: The ID for a top-level mission or aggregate is now optional. When omitted, TethysL will infer the ID from the filename.

    For example, Science/ can now start with just:

    mission {
      Vehicle yo-yo's to the specified waypoints, with science turned on.
    and still get (implicitly) assigned the ID sci2 as usual.

    When an explicit ID is given, VSCode will report one of the following two warnings (in both cases with a "Remove ID" quick fix):

    • The ID is redundant

    • The ID does not correspond to the filename

  • Fix in the VSCode extension: The list of completions within an insert body now only includes the actual possible options: a description """...""" (when the body is still empty), redefineArg statement, and closing the body }.



  • VSCode extension now with initial incorporation of the "Quick fix" feature, at the moment only for the warning related with inconsistent ID of the script with respect to the filename, but other quick fixes may be added in future versions (let us know if you have any suggestions.)

  • Additional handling of multiple diagnostics.

  • Some internal code cleanup.



  • The VSCode extension now supports an initial version of the rename operation ("Rename Symbol") for arguments and outputs.


    The symbol renaming operation is only done within the same file. We hope to be adding cross-file symbol renaming in some future version.



  • Fixed TethysL parser to actually follow the specified structure for the EndRunGroup element in the XML schema. Previously, after the arguments/output section in a mission or aggregate, the parser would allow, optionally, either a break if ( ... ) or a timeout ..., but not both. The fix is that both can be indicated (in that order). Thanks, Mike G., for reporting and the feedback.

  • VSCode extension: Fixed a regression where navigating to the references of a definition, or back from a reference to its definition, had got broken.

  • Any invalid boolean expressions in break if ( ... ), run when ( ... ), etc., are now reported again. (Note: this is part of some pending adjustments after the recent addition of multiple diagnostics reporting.)



  • General handling improvement (and a fix) when one opens a .tl file that does not belong to the workspace in VSCode. Thanks, Mike G., for reporting. In this scenario, mission and LRAUV definition inserts/references are still resolved against the relevant locations as determined when opening the workspace.
  • The XML-to-TethysL translator now translates any &lt; entities in <Description> bodies to just < on the TethysL result.
  • Cleanup: Removed the old (and unneeded) XML reformatting mechanism based on the traditional script in lrauv-application.



A release with significant enhancements. Your continued feedback is appreciated.

  • Warnings. Compile warnings are now also generated.

    The possible warnings in this initial implementation are:

    • Inconsistent ID for top-level mission or aggregate according to the file name.

    • Unused argument or output in a mission or aggregate (including embedded aggregates).

      A warning for an unused argument or output is actually reported unless the name starts with an underscore _.

    Disabling the warning inspections:

    • VSCode extension: Use the tethysl.noWarnings setting.
    • CLI: Use the --no-warnings option for the compile command.


    From the command line (tethysl compile ...), warning inspections are always disabled for scripts whose path contain "Deprecated" or "RegressionTest".

  • Multiple diagnostics. In case of multiple compile errors or warnings in the script, they are now reported in a single set of diagnostics, instead of just reporting the very first error.


    In this initial implementation, depending on the concrete errors, the generation of warnings may not be totally accurate. We plan to continue improving the underlying logic in future versions.

  • Validation fixes:

    • The names of aggregate definitions in a block are now verified for duplication.
    • A reference to an aggregate argument parameter, like to Aggr12:quz in

      assign in sequence Aggr12:quz = 42 meter
      is now properly resolved when the aggregate (Aggr12) is defined via macro.



  • VSCode extension: The mechanism to create/update generated files (.tx, has been improved, in particular, to avoid the "dirty" indicator in the editor and associated need for a subsequent save action by the user. Internally, the files are now directly saved, and VSCode should automatically pick up the update:

    • a new file shows up in the explorer;
    • content updates get reflected in the editor if file already opened.

    The previous mechanism was in general acceptable but actually confusing because of the resulting "dirty" state in the editor, specially when doing a xml-to-tl migration, but also when simply having the "Generate .tx" flag enabled. Occasional errors like Unexpected: end-of-input would be triggered.



  • Fix in VSCode extension: The preemptive keyword is now handled for hover and link to documentation.
  • CLI: tethysl lint --all now ignores paths containing "Deprecated" or "RegressionTest".





  • Adjustments/additions in handling of "prettify" commands:

    • New VS Code extension commands to process all .tl files in the workspace:

      • TethysL: Check format of all .tl files
      • TethysL: Format all .tl files

      The command will display a report of the result in a panel window, including a summary of the various possible cases (already pretty, not formatted, not compiling, etc.), for example:

    • CLI prettify --all with improved report and summary.



  • The VSCode extension now provides more details on hover, as well as navigation from, for example, Science:CTD_Seabird.sea_water_salinity, to corresponding definition in C++ source location (when the lrauv-application codebase is available).

    As an example, includes:

    readData strategy="MinError" {
      while ( EnabledSeabird )
    Unlike many other cases, this kind of definition is not captured in *IF.h headers, but indirectly via calls to newUniversalWriter in module .cpp files.

  • Internal code reorg and cleanup.



  • The VSCode extension Reload Base Information command now also works for when using a published set of LRAUV definitions (that is, when using the LRAUV Revision setting). See 2.9.90 notes below for more details on this feature.
  • Internal adjustments.



This important release is primarily intended to better support TethysL users with no access to the lrauv-application codebase. The new support involves two main aspects:

  1. Publication of lrauv-application definitions by MBARI:

    • The definitions get published under This happens in two main ways:

      • As part of the regular lrauv-application nightly build process
      • LRAUV developers can also trigger the update whenever needed, and not only for master, but for any other branch as needed:

        make tl-publish-lrauv-info

      The published revision identifier will be the latest commit hash of the checked-out branch. Also, a soft link with the name of the branch is created for convenience.

  2. Now in VSCode, the user can instruct TethysL to use a published set of LRAUV definitions by indicating the corresponding revision identifier:

    • Open the VSCode Settings window and filter for example by "tethysl" to quickly find the TethysL settings. The new setting is named LRAUV Revision, and the attached screenshot shows master as the value.

    • Reload your workspace for any change in this setting to have effect (you can use the Developer: Reload Window command).

    • TethysL will now use those published definitions for all validations in the editor.
    • The user can also trigger a reload of the definitions at any time by running the usual Reload Base Information command:

      A summary of the reloaded definitions will be shown in the output window:


For CLI users, there's a corresponding new option --lrauv-revision for the compile command.



  • Maintenance release including these changes:

    • CLI compile command: If no --mission-dir option is given, then the compile command now defaults to current directory as base for any mission inserts.


      However, when the CLI discovers there's a lrauv-application codebase available depending on the given mission file path, then it will try to determine the associated Missions/ subdirectory as such base for any mission inserts.

    • VSCode extension: Hovering on some behavior settings was triggering an error instead of showing the associated information. Fixed.



  • Maintenance release:
    • Embedding LRAUV resources as of lrauv-application commit faa20085d2a (Jul 15), which includes new settings that are used in WHOI missions.
    • Some code cleanup and minor fixes.



  • First release with a proper parser for lrauv-application xyzModule/XyzModule.cpp files to extract the module information, that is, not using the traditional scripts there(*). The new parser already seems to be covering most, if not all of, what the traditional scripting has provided, and even including some fixes (for issues like missing entries, duplicates).

    (*) Note

    Our immediate plan is to have the new parser enabled for some time to facilitate testing by others, but the final parsing mechanism for LRAUV module information is still TBD.

  • Other updates:

    • VS Code extension: The user can now do searches in the resulting panel created by some commands (for example, upon running TethysL: Reload Base Information).
    • VS Code extension: Fixed regression that prevented navigating from a call refId to corresponding referenced element.
    • Fix: *IF.h parser would not always capture all namespace members.



  • Fix in xml-to-tethysl related with translation of comments in expression



  • Improved prettification of syslog statements: If no printed fragment has any comments associated, TethysL will split the set of fragments into new lines as needed so no individual line gets too long. Example of resulting formatting:
    syslog "Depth=" + Universal:depth~meter + ", Thermocline Depth = "
         + Derivation:TempGradientCalculator.thermoclineDepth~meter + ", Target depth = "
         + Derivation:TempGradientCalculator.targetDepth~meter



Further improvements toward facilitating XML migrations to TethysL.

2023-05-31 - 2.9.1

This release brings the following significant improvements:

  • The XML-to-TethysL translator now performs a more complete handling of expressions in terms of retaining the traditional but non-standard evaluation semantics performed by the LRAUV framework.


    At the TethysL level, expression evaluation continues to follow the standard practice in most common programming languages, in particular, in terms of operator precedence and associativity.

  • Reformatting of expressions involving nested sub-expressions now results in significantly more legible structure. As an example (taken from translation of the circle_sample mission):

    run when (
      and not ( FlagSamplingOngoing )
      and CntSamples <= NumSamplers
      and SampleOptionsSet
      and not ( SampleCompleted )
      and (
        CntSamples == 1 count
        and (
          and not ( OtherLRAUVSampleStartReceived )
          and elapsed ( ElapsedSinceStartOrLastFiring ) > MaxWaitFirstSample
          or (
            not ( UseOtherLRAUVSignals )
            and elapsed ( ElapsedSinceStartOrLastFiring ) > MaxWaitFirstSample
        or elapsed ( ElapsedSinceStartOrLastFiring ) > MaxWaitMustFire

Other adjustments include:

  • VS Code extension: For the "Format Document" command, now the user is notified when there's any syntax error that prevents the operation from proceeding.
  • Though redundant, now an optional bool "units" is allowed after a boolean literal expression (e.g., true bool or false bool). Such cases are found when translating from some XML missions, so this is intended to further facilitate the migration efforts.
  • Improved prettification of not expressions.
  • Fix in the XML-to-TethysL translator: Any """ in a <Description> content is now replaced with something else (''') in the generated TethysL (otherwise it would conflict with the regular """ delimiter).



  • TethysL VS Code extension enhancements, including new commands for mission regression testing and xml/tx diffing to facilitate XML-to-TethysL conversions.



  • Fixes in the VSCode TethysL extension regarding the automatic download of its dependencies at activation time. (In particular, various fixes related with the download of Java when needed. For more details, see the VSCode extension page. Tested on Windows and Linux machines with no prior Java installation.)



  • Fixed a regression exposed when opening the lrauv-application codebase directly in VSCode. Thanks, Quinn, for reporting and testing!



  • Various code adjustments and documentation updates toward resuming the conversion of XML scripts to TethysL.



  • Several fixes in both the VSCode extension and the TethysL language server, so the system should now be functional on the Windows platform. Please let us know if you encounter any issues.
  • Fixes and adjustments mainly related with the validation of arrays, that is, arguments or output variables using the foo[1..10] syntax as supported by TethysL. As an example, one can now have an argument definition CartridgeType[1..60] and also an output variable CartridgeType, which was previously not allowed.



  • Several internal dependencies updated, and some fixes.

  • Note: The Java-based release is the recommended and fully tested mechanism to install the TethysL CLI. The binary releases continue to be auto-generated from the Java one, but, unfortunately, are proving unreliable in general. If you cannot use the Java based release, please let us know to determine possible solutions.



  • TethysL CLI: Various internal adjustments, including the direct parsing of C++ module information to support the case of possibly using a different branch or tag of the lrauv-application codebase.

  • TethysL VSCode extension 2.4.5 (and requiring TethysL CLI 2.4.5+), now includes a command for the conversion of the currently open XML script to TethysL. See the Migrating from XML page for more details.



  • Language: Related with the array/macro extensions, one can now use a static, simple addition/subtraction expression in two general cases:

    • Anywhere where a number expression can be used, e.g., $( $k - 1 ) count

      Note: The $( ... ) construct is to group the static expression itself.

    • Array index expression, e.g., Latitude[$k - 1]

      Note: The usual [ ... ] serves as the grouping construct for the static expression.

    "Static" here means that the expression is only to be evaluated at compile time, with the resulting value used in the generated XML. The expression can only involve literal numbers (excluding NaN), and macro variable. Typically, this feature is to be used within the context of a macro.

    Here's an example (as used in _examples/

    macro $k = 2..5 {
      aggregate Leg$k {
        run in sequence
          break if ( leg <= $( $k - 1 ) count )
          assign in sequence {
            Lat[$k - 1] = NaN degree
            Lon[$k - 1] = NaN degree
  • Validation adjustments for macro.

  • LSP: Added basic references handling. (For now, both references and definitions are handled in the same way.)



  • Now, explicit extension for all inserts is required. This avoids confusion given that both .tl and .xml inserts are supported, and also fixes an interlinking issue in the markdown generation.
  • Various adjustments and fixes (source reformatting, markdown generation).





  • TethysL CLI 2.0.5 released, with binary executables available for Linux, macOS, and Windows. See CLI.

  • VSCode extension 2.0.5 published (requires TethysL CLI 2.0.5). See VSCode.



  • TethysL CLI 1.9.0 and VSCode extension 1.9.0 released.

  • TethysL CLI: the markdown command (which supports the automatic generation of some content exposed here) has been expanded to also generate pages for Units and Universals.

  • Various LSP related enhancements

    • Smart handling of the lrauv-application "workspace" for resolution of inserts. That is, in this case, the server determines the actual base mission directory to be Missions/ (instead of the workspace directory itself).
    • Improved go-to-definition functionality: when dealing with a lrauv-application workspace, a behavior resolution will now point to corresponding IF*.h header file, and even to the specific line when resolving a particular setting.
  • Language syntax adjustment: Quotes are not needed anymore for the filename in an insert construct. So, one now writes insert Insert/NeedComms ... instead of insert "Insert/NeedComms" ....

  • Various validation improvements and fixes in the language engine.

  • XML generation now with https:// for schema hrefs (instead of http://). This is a pretty standard best practice, and should not have any impact on the LRAUV.

  • Reformatting of a .tl source now simplifies the behavior setting IDs (by removing the redundant prefix corresponding to the behavior itself).

    As an example, with this source (originally, a direct translation from some XML file):

    behavior Trigger:PeakDetectVsDepth {
      run in sequence
      set Trigger:PeakDetectVsDepth.detect = Universal:mass_concentration_of_chlorophyll_in_sea_water
      set Trigger:PeakDetectVsDepth.timeWindowPeakReport = TimeWindowPeakReport
      set Trigger:PeakDetectVsDepth.windowLength = LowPassWindowLength
      set Trigger:PeakDetectVsDepth.medianFilterLength = MedianFilterLen
      set Trigger:PeakDetectVsDepth.shallowBound = PeakShallowBound
      set Trigger:PeakDetectVsDepth.deepBound = PeakDeepBound
      set Trigger:PeakDetectVsDepth.depthChangeThresh = DepChangeThreshForAttitudeFlip
      outputArg PeakChl = Trigger:PeakDetectVsDepth.peakDetect
      outputArg PeakChlDepth = Trigger:PeakDetectVsDepth.peakDepth
      outputArg PeakChlTemperature = Trigger:PeakDetectVsDepth.peakTemperature
      outputArg PeakChlLatitude = Trigger:PeakDetectVsDepth.peakLatitude
      outputArg PeakChlLongitude = Trigger:PeakDetectVsDepth.peakLongitude

    the reformatting results in the following, semantically equivalent but more legible:

    behavior Trigger:PeakDetectVsDepth {
      run in sequence
      set detect = Universal:mass_concentration_of_chlorophyll_in_sea_water
      set timeWindowPeakReport = TimeWindowPeakReport
      set windowLength = LowPassWindowLength
      set medianFilterLength = MedianFilterLen
      set shallowBound = PeakShallowBound
      set deepBound = PeakDeepBound
      set depthChangeThresh = DepChangeThreshForAttitudeFlip
      outputArg PeakChl = peakDetect
      outputArg PeakChlDepth = peakDepth
      outputArg PeakChlTemperature = peakTemperature
      outputArg PeakChlLatitude = peakLatitude
      outputArg PeakChlLongitude = peakLongitude



  • The Tethysl CLI can now generate documentation pages for all .tl missions under a given directory.

  • The behavior construct now always require a body and the specification of the execution mode, which now goes in the body and not in the "header".

    This is intended for consistency with other constructs.

    Example, now:

    behavior Guidance:Buoyancy {
      run in parallel
      set position = BuoyancyNeutral


    behavior Guidance:Buoyancy in parallel {
      set position = BuoyancyNeutral
  • Delimitation of test_code blocks is now with {{{ and }}}.


  • TethysL engine undergoing enhancements mainly toward implementing the Language Server Protocol so the editing capabilities can be leveraged in diverse development tools. Initial focus on VS Code. Details will be captured in the vscode section.

(Older change notes here.)