The user should be able to modify the array schema (e.g., add/remove attributes, change filters, tile capacity, etc) and time travel over the different versions.

TileDB should support slicing with strides, which is quite common in numpy and similar tools.

Enable use of TileDB from Julia ( www.julialang.org ).

A common use case if to update a zero-filled array with values obtained from reads of a TileDB.SparseArray. Would be good if we at array creation time or read time specify that empty cells have some default value (0) and at read time we could get a dense array straight from TileDB - would be better than create a dense zero-filled array from numpy and fill in iteratively using the results from TileDB

TileDB does not allow arrays to change size. Appending new data and removing old data along a specific dimension (ex. time) is useful for realtime applications.

TileDB should support attaching axes labels (dataframes in their full generality), so that the user can slice the array based on arbitrary axes label predicates.

TileDB currently performs only slicing. It should allow other computations, such as filters, group-by queries and joins. This will help high-level application push compute closer to storage.

It would be cool to have the possibility to combine multiple tiledb arrays in a single logical view. A simple and fast way would be to require the same schema and just combine individual fragments s.t. the latest write wins. A more useful option would be to also allow concatenation of arrays along some dimension. In Dask, this could be exported as a single array with chunks aligned to the dataset borders. Even better, one could include filtering options or joining by keys. See also the discussion in https://github.com/TileDB-Inc/TileDB/issues/1475 .

Some processing on arrays (e.g., convolution) requires "tile overlaps". In other words, it is sometimes necessary to declare an array that consists of tiles which overlap certain amounts with one another. I think that TileDB would be better if the feature is supported.

It would be super cool to have a distributed database with co-located processing on top of TileDB. Apache Ignite is such a distributed database engine but it currently only supports table-based data. My dream is a distributed array database that allows: fast selection along dimensions (-> secondary indices) fast distributed joins co-located processing