Dace

What's Changed
* If a Python call cannot be parsed into a data-centric program, DaCe will automatically generate a callback into Python. Supports CPU arrays and GPU arrays (via CuPy) without copying!
* Python 3.10 support
* CuPy arrays are supported when calling `dace.program`s in JIT mode
* Fix various issues in Python frontend and code generation

**Full Changelog**: https://github.com/spcl/dace/compare/v0.11.3...v0.11.4

What's Changed
* Minor fixes to exceptions in Python parsing.


**Full Changelog**: https://github.com/spcl/dace/compare/v0.11.2...v0.11.3

What's Changed
* Various bug fixes to the Python frontend


**Full Changelog**: https://github.com/spcl/dace/compare/v0.11.1...v0.11.2

What's Changed
* More flexible Python frontend: you can now call functions and object methods, use fields and globals in `dace` programs! Some examples:
* There is no need to annotate called functions
* `dataclass` and general object field support
* Loop unrolling: implicit and explicit (with the `dace.unroll` generator)
* Constant folding and explicit constant arguments (with `dace.constant` as a type hint)
* Debuggability: all functions (e.g. `dace.map`, `dace.tasklet`) work in pure Python as well
* and many more features
* NumPy semantics are followed more closely, e.g., subscripts create array views
* Direct CuPy and `torch.tensor` integration in `dace` program arguments
* Auto-optimization (preview): use `dace.program(auto_optimize=True, device=dace.DeviceType.CPU)` to automatically run some transformations, such as turning loops into parallel maps.
* ARM SVE code generation support by sscholbe (705)
* Support for MLIR tasklets by Berke-Ates in (747)
* Source Mapping by benibenj in https://github.com/spcl/dace/pull/756
* Support for HBM on Xilinx FPGAs by jnice-81 (762)

Miscellaneous:
* Various performance optimizations to calling `dace` programs
* Various bug fixes to transformations, code generator, and frontends

**Full Changelog**: https://github.com/spcl/dace/compare/v0.10.8...v0.11.1

What's New?

* Various bug fixes and more stable Python/NumPy frontend
* Support for running DaCe programs within the Python interpreter
* (_experimental_) Support for automatic optimization passes (more coming soon!)

What's New?

* **Python frontend improvements**: More Python features are supported, such as return values, tuples, and [numpy broadcasting](https://numpy.org/devdocs/user/theory.broadcasting.html). `dace.program`s can now call other programs or SDFGs.
* **AMD GPU (HIP) Support**: AMD GPUs are now fully supported with HIP code generation.
* **Easy-to-use transformation APIs**: Apply transformation compositions with one call, enumerate subgraph matches manually, and many more functions now available as part of the dace API. [See the new tutorial](https://nbviewer.jupyter.org/github/spcl/dace/blob/master/tutorials/transformations.ipynb) for examples.
* **Faster code generation**: Backends now generate lower-level code that is more compiler-friendly.
* **Instrumentation interface**: Setting the `instrument` property for SDFG nodes and states enables easy-to-use, localized performance reporting with timers, GPU events, and PAPI performance counters.
* **DaCe VSCode plugin**: Interactive SDFG viewer and optimizer as part of Visual Studio Code. Download the plugin [here](https://marketplace.visualstudio.com/items?itemName=phschaad.sdfv).
* **Type inference and connector types**: In addition to automatic type inference, connectors on nodes can now be defined with explicit types, giving more fine-grained control over type reinterpreting and vector types.
* **Subgraph transformations**: New transformation type that can work on arbitrary subgraphs. For example, fuse any computation within a state with `SubgraphFusion`.
* **Persistent GPU kernel schedule**: Launch persistent kernels with a change of a property! Proportion used of GPU multiprocessors is configurable.
* **More transformations**: Loop manipulation and other new transformations now available with DaCe. Some transformations (such as `Vectorization`) made more robust to corner cases.
* **More tools**: Use `sdfgcc` to quickly compile and optimize `.sdfg` files from the command line, generating header and library files. Great for interoperability and Makefiles.
* **Short DaCe annotation**: Data-centric functions can now be annotated with `dace`.
* **Many minor fixes and additions**: More library nodes (such as `einsum`) and new properties added, enabling faster performance and more productive high-performance coding than ever.