Releases: cmajor-lang/cmajor
0.9.2233
0.9.2224
Version 0.9.2224
Added Patch Worker support
When running a patch headless, it is sometimes helpful to be able to perform work on the host. A new patch worker can be specified in a patch which allows for a js worker to interact with the loaded patch. See https://github.com/SoundStacks/cmajor/tree/main/examples/patches/PatchWorker for an example
Added ML inference script
There is a new script in tools/rtneural which adds support for an RTNeural to Cmajor transpiler - RTNeural json files can be converted into a Cmajor patch which implements the same ML inference.
Bug fixes
Fixed issues around specialisation of processors and functions with multi-dimensional arrays which lead to failure with unhelpful error messages.
Fixed issues related to value endpoints when used in oversampled nodes which could cause compiler failure, or empty values being passed into the node.
Fixed an implementation problem that lead to NaN being returned from tanh in some situations
Fixed an issue where processor.period would return an incorrect value when used in an oversampled node
Resolved a C++ generation issue with void types which could lead to code which didn't compile
Fixed a timeout issue when building under VSCode which could lead to failures to communicate with the runtime infrastructure
Resolved a problem which could lead to incorrect code generation for functions operating on slices.
0.9.2209
Version 0.9.2209
Added Patch Worker support
When running a patch headless, it is sometimes helpful to be able to perform work on the host. A new patch worker can be specified in a patch which allows for a js worker to interact with the loaded patch. See https://github.com/SoundStacks/cmajor/tree/main/examples/patches/PatchWorker for an example
Bug fixes
Fixed issues around specialisation of processors and functions with multi-dimensional arrays which lead to failure with unhelpful error messages.
Fixed an implementation problem that lead to NaN being returned from tanh in some situations
Resolved a C++ generation issue with void types which could lead to code which didn't compile
Fixed a timeout issue when building under VSCode which could lead to failures to communicate with the runtime infrastructure
Resolved a problem which could lead to incorrect code generation for functions operating on slices.
0.9.2170
New language features
Some matrix operations have been added to the standard library. See https://cmajor.dev/docs/StandardLibrary#std_matrix for details
We have added support for if statements within graph connections. For now, the condition must be a compile time constant, so it cannot be used for dynamic routing. See https://cmajor.dev/docs/LanguageReference#conditional-connections for details.
Processors now support processor composition. This allows a wrapping processor to declare node instances, and to control how the input and output endpoints from the wrapped processor (and it's associated DSP) is called. This allows for things like bypass algorithms to be written efficiently, as well as complex dynamic routing algorithms. See https://cmajor.dev/docs/LanguageReference#processor-composition for details.
The rules for automatic conversion of constants have been tightened up, which may require casts to be added in places where previously the compiler would allow conversion. Specifically this rule may affect situations where runtime constants, such as processor.frequency are used. Adding the cast will restore the previous functionality.
Bug fixes
Resolved a possible name clash with JUCE classes when generating C++.
Resolved a problem with the default GUI where gesture ends were being send at the wrong time causing assertions within JUCE.
The error reporting around invalid node connections has been improved, giving more nuanced error messages.
A subtle problem related to slices of arrays which could trigger use-after-free type errors has been resolved.
Fixed an issue with incorrect warnings being generated for unsafe array access in some situations.
0.9.2131
New language features
The compiler now supports multi-dimensional arrays. The syntax uses the [a, b, c...] style sytax to declare multiple dimensions, see the language documentation here - https://cmajor.dev/docs/LanguageReference#multi-dimensional-arrays
External values have been reworked, allowing for more constructs to be supported, such as endpoint data types depending on supplied external values. In addition, the main module may now be parameterised, with external parameters being used to supply these parameter values.
We now support void as a valid data type for event endpoints. This is useful in situations where you want to communicate but there is no obvious value associated with the event. See the documentation for the syntax required for the event handler functions, and sending void messages within the graph.
Changes have been made to the way the main processor is determined. Previously the rules were not well defined when multiple suitable candidates were available. The compiler now gives an error, and you must specify a main processor with the [[ main ]] annotation. Additionally, patches can override the main processor by specifying a mainProcessor attribute.
Constant folding has been reworked, leading to compilation and code generation improvements where large constant data is declared.
Compile time improvements
The compile time has been significantly reduced for some situations which were previously causing slow compilation. Variable name lookup has been
reworked, and the implementation of large static arrays, giving benefits both to the parser, optimisations, and LLVM backend.
Timeline info
The patch player now sends through tempo information to the patch if required.
Bug fixes
Improvements have been made to error generation for some edge cases - slices and loop condition validation has been improved giving better error reporting when invalid expressions are used.
Resolved various problems with using complex values on stream endpoints.
Fixed an issue which could in some circumstances cause the return value of a function to be invalid.
Warnings were sometimes not being displayed in the VSCode panel - this has been resolved.
A problem related to graph nodes where multiple instances of the same processor type could cause incorrect code generation has been resolved.
A problem with references to array slices in the LLVM backend has been fixed.
A problem with empty structs as event types has been resolved.
An issue related to casts in graph connections when using delays has been resolved.
Internal updates
There has been significant work on the implementation of compiler intrinsics for WASM, giving a more maintainable implementation.
Some superfluous state members have been removed, giving a smaller state image size at runtime.
The default javascript GUI components have been support for touch displays.
A detector for infinite loops has been added providing logic to terminate performers which are taking too long to execute.
0.9.2051
Updated patch parameter logic
The rules around discrete parameters (ones specifying a step annotation) were confusing and inconsistent. This logic has been updated, adding a discrete option. See the patch documentation for more details.
Standard Library updates
Fixed an issue with the LFO which caused it to fail to instantiate. Resolved issues with triangle waveform output.
Bug fixes
Resolved an issue that could cause a runtime problem when attempting to play a malformed patch. This now reports the correct error.
Improved the load performance when the patch includes large arrays of data (e.g. pre-calculated tables, or external sample data).
Fixed the c++ generator so that it doesn't produce symbols with two leading underscores to avoid conflicts with reserved symbols on different platforms.
Resolved a problem on windows which could cause connection problems when starting the service in VSCode
Breaking changes to javascript API
We've extensively refactored the javascript API used by the patch GUI's (mainly the PatchConnection class). It now provides a better system for adding/removing multiple listeners rather than having a single callback function to respond to events. It has also gained more helper methods and more complete documentation.
0.9.2006
Standard Library updates
Fixed an issue with the LFO which caused it to fail to instantiate. Resolved issues with triangle waveform output.
Bug fixes
Resolved an issue that could cause a runtime problem when attempting to play a malformed patch. This now reports the correct error.
Breaking changes to javascript API
We've extensively refactored the javascript API used by the patch GUI's (mainly the PatchConnection class). It now provides a better system for adding/removing multiple listeners rather than having a single callback function to respond to events. It has also gained more helper methods and more complete documentation.
0.9.1967
VSCode updates
This version includes a significantly upgraded VSCode experience. The VSCode extension has a re-worked user interface providing metering on inputs and outputs, and the ability to mute (disable) and connect files to input streams. The graph panel shows a visualisation of the Cmajor patch, with links to the components within the source code. Panels are also provided for access to and control over the audio subsystem in use, and the ability to view generated code for supported target platforms.
The VSCode extension supports macOS (x64 and arm64), Windows (x64 and arm64) and Linux (x64) platforms.
Updated std library
The standard library has been updated. std::smoothing can now be parameterised to smooth different data types (e.g. float64, or float<2>) and the algorithm produces more accurate results for longer smoothing intervals. lerp has been updated to support vector types.
Various bug fixes
The graph printer was struggling to correctly identify implicit graph nodes, leading to failure to generate some graphs.
Logic to check the scope of variables used in slices could lead to compilation failure.
Better support for graph connections using arrays of indexes, with clearer error reporting for incorrect use.
Resolved issues in the LLVM code generator which could lead to failure to compille some if statements involving return statements.
0.9.1937
Improved VSCode integration
Significant work has been completed on the integration of Cmajor and VSCode. The Cmajor extension for VSCode now opens an integrated panel in VSCode containing both the user interface and additional views of the top level inputs and outputs, audio graph, and simple transport controls (e.g. start/stop audio). Visualisation of the data flowing through the patch are displayed.
Graph generation
The command line tool now includes a graph generation option (via generate --target=graph) which produces a visual representation of the audio graph and endpoint connections.
Support for windows Arm64 platforms
The tooling and VSCode extension now include releases for windows on arm64.
Improved support for indexes in connections and graph event handlers
Indexes can now be specified for nodes and endpoints allowing graph nodes arrays and endpoints arrays to specify individual routing rules. In addition, graph event handlers can also write to event endpoints specifying node indexes and endpoints indexes.
Various bug fixes
Some issues related to graph event handlers have been resolved, allowing more sophisticated expressions to be used
Top level event handlers with multiple types could lead to compilation errors from the C++ backend, this is now resolved.
Resolved an issue with using empty structures in event handlers
Fixed issues in the standard library related to vector support for the pow() function