Simply execute the following commands:

$ git clone https://github.com/TileDB-Inc/TileDB-Py.git
$ cd TileDB-Py
$ pip install .
$ cd .. # exit the source directory to avoid import errors

If you wish to modify the install process, you can use these environment variables:

• TILEDB_PATH: Path to TileDB core library. If this variable is set and the library is found in the specified folder it is not copied inside of the wheel.

• TILEDB_VERSION: Version of the TileDB core library that you wish to download. This version must be present in the Github releases.

• TILEDB_HASH: SHA256 sum of the desired TileDB core library release. Only used when TILEDB_VERSION is set.

$ TILEDB_PATH=/home/tiledb/dist pip install .
# Or pass it as an argument
$ pip install . -C skbuild.cmake.define.TILEDB_PATH=/home/tiledb/dist

To build against libtiledb installed with conda, run:

# After activating the desired conda environment
$ conda install tiledb
$ TILEDB_PATH=${PREFIX} python -m pip install --no-build-isolation --no-deps --ignore-installed -v .

To test your local installation, install optional dependencies, and then use pytest:

$ pip install .[test]
$ python -m pytest -v # in the TileDB-Py source directory

If TileDB is installed in a non-standard location, you also need to make the dynamic linker aware of libtiledb's location. Otherwise when importing the tiledb module you will get an error that the built extension module cannot find libtiledb's symbols:

$ env LD_LIBRARY_PATH="/home/tiledb/dist/lib:$LD_LIBRARY_PATH" python -m pytest -v

For macOS the linker environment variable is DYLD_LIBRARY_PATH.

If you are building the extension on Windows, first install a Python distribution such as Miniconda. You can then either build TileDB from source, or download the pre-built binaries.

Once you've installed Miniconda and TileDB, execute:

REM with a conda install of libtiledb:
> pip install .

REM with a TileDB source build:
> set TILEDB_PATH=C:/path/to/TileDB/dist/bin
> pip install .

REM to run tests:
> pip install .[test]
> python -m pytest -v

Note that if you built TileDB locally from source, then replace set TILEDB_PATH=C:/path/to/TileDB with TILEDB_PATH=C:/path/to/TileDB/dist.

The core TileDB library can be installed easily using the Homebrew package manager for macOS. Install instructions for Homebrew are provided on the package manager’s website.

To install the latest stable version of TileDB:

$ brew update
$ brew install tiledb-inc/stable/tiledb

HDFS and S3 backends are enabled by default. To disable one or more backends, use the --without- switch to disable them:

$ brew install tiledb-inc/stable/tiledb --without-s3
$ brew install tiledb-inc/stable/tiledb --without-hdfs

A full list of build options can be viewed with the info command:

$ brew info tiledb-inc/stable/tiledb

Other helpful brew commands:

# Upgrade to the latest stable version of TileDB
brew upgrade tiledb-inc/stable/tiledb

# Uninstall TileDB
brew uninstall tiledb-inc/stable/tiledb

The Homebrew Tap is located at https://github.com/TileDB-Inc/homebrew.

TileDB is available as a pre-built Docker image. For a latest version, run:

$ docker pull tiledb/tiledb
$ docker run -it tiledb/tiledb

For a specific TileDB version, run:

# <version> could be 1.2.0
$ docker pull tiledb/tiledb:<version>
$ docker run -it tiledb/tiledb:<version>

A package for TileDB is available for the Conda package manager. Conda makes it easy to install software into separate distinct environments on Windows, Linux, and macOS

$ conda create -n tiledb
$ conda activate tiledb
$ conda install -c conda-forge tiledb

If you are compiling / linking against the TileDB conda package, you may need to explicitly add the conda path after activating the environment with conda activate tiledb, sinceconda activate sets the CONDA_PREFIX environment variable:

$ export CPATH=$CONDA_PREFIX/include
$ export LIBRARY_PATH=$CONDA_PREFIX/lib
$ export LD_LIBRARY_PATH=$CONDA_PREFIX/lib

Instead of exporting those environment variables, you can pass them as command line flags during compilation:

$ g++ -std=c++17 example.cpp -o example -I$CONDA_PREFIX/include -L$CONDA_PREFIX/lib -ltiledb

You can download pre-built Windows binaries in the .zip file from the latest TileDB release. You can then simply configure your project (if you are using Visual Studio) according to the Windows usage instructions.

TileDB binaries for each release are available on GitHub Releases for the following operating system and architecture combination:

• Windows on x64

• macOS on x64

• macOS on Apple Silicon (arm64)

• glibc-based Linux on x64 (with and without AVX2 support)

These binaries are also available on NuGet, for use by the C# API.

# -- from CRAN
# install most recent release from CRAN
install.packages("tiledb")

# -- alternatively, install from source via GitHub
# install the 'remotes' package if needed
# install.packages("remotes")
library(remotes)
install_github("TileDB-Inc/TileDB-R", ref = github_release())

# -- verify install
library(tiledb)
tiledb::tiledb_version()
#> major minor patch 
#>     2     0     8

Using TileDB From Custom Location

If the TileDB library is installed in a custom location, you need to pass the explicit path:

library(remotes)
install_github("TileDB-Inc/TileDB-R",
               ref = github_release(),
               args="--configure-args='--with-tiledb=/path/to/tiledb'")

Note on Installing with Conda

If you are using R inside conda and want to install TileDB-R you might run into a issue with devtools/remotes around gtar. The error is below:

Downloading GitHub repo TileDB-Inc/TileDB-R@master
sh: 1: /bin/gtar: not found
sh: 1: /bin/gtar: not found
Error: Failed to install 'tiledb' from GitHub:

To fix this, simply export the TAR environmental variable before starting R

# Inside conda environment
TAR=`which tar` R

> # Follow instructions at start for installing TileDB-R

Use the TileDB.CSharp NuGet package to create a .NET console application with the .NET CLI. The TileDB NuGet package is currently compatible with .NET 5 and above.

# Create a new .NET solution
$ dotnet new sln -o TileDB-Project
$ cd TileDB-Project
# Create a new console project using .NET CLI
$ dotnet new console -o ConsoleApp
$ dotnet sln add ConsoleApp/ConsoleApp.csproj

# Add TileDB.CSharp NuGet package to the project
$ dotnet add ConsoleApp/ConsoleApp.csproj package TileDB.CSharp

After running the commands above our TileDB-Project/ConsoleApp/ConsoleApp.csproj will have the following configuration, providing access to the TileDB-CSharp API in our project.

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net5.0</TargetFramework>
    <RootNamespace>TileDB_Project</RootNamespace>
    <!-- Use one of the following options to set an RID: -->
    <!-- This sets a specific RID. Useful for deployment. -->
    <RuntimeIdentifier>win10-x64</RuntimeIdentifier>
    <!-- This sets the RID to the one of your machine.
    Useful for development. -->
    <UseCurrentRuntimeIdentifier>true</UseCurrentRuntimeIdentifier>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="TileDB.CSharp" Version="5.3.0" />
  </ItemGroup>

</Project>

To test our project we can edit TileDB-Project/ConsoleApp/Program.cs and obtain the version of TileDB core currently in use by TileDB.CSharp. For more examples using the C# API see the TileDB-Inc/TileDB-CSharp repository on GitHub.

using System;
using TileDB.CSharp;

namespace TileDB_Project
{
    class Program
    {
        static void Main(string[] args)
        {
            var version = CoreUtil.GetCoreLibVersion();
            Console.WriteLine($"TileDB Core version: {version}");
            // TileDB Core version: 2.13.1
        }
    }
}

# Go Get
$ go get -v github.com/TileDB-Inc/TileDB-Go

# Go modules
go mod init github.com/<github_username>/repository_name

Here is a sample go.mod file:

module github.com/<github_username>/repository_name

go 1.13

require (
	github.com/TileDB-Inc/TileDB-Go v0.6.0
)

To use TileDB C API in a program, just add #include <tiledb/tiledb.h> and specify -ltiledb when compiling, e.g.

$ gcc example.c -o example -ltiledb

To use the C++ API, add #include <tiledb/tiledb> to your C++ project instead. The TileDB C++ API requires a compiler with C++17 support, thus your project must be compiled using the C++17 standard, e.g.

$ g++ -std=c++17 example.cpp -o example -ltiledb

If TileDB was installed in a non-default location on your system, use the -I and -L options:

$ gcc example.c -o example -I<path/to/TileDB>/include -L<path/to/TileDB>/lib -ltiledb

At runtime, if TileDB is installed in a non-default location, you must make the linker aware of where the shared library resides by exporting an environment variable:

$ export DYLD_LIBRARY_PATH="<path/to/TileDB>/lib:$DYLD_LIBRARY_PATH"
$ ./example

$ export LD_LIBRARY_PATH="<path/to/TileDB>/lib:$LD_LIBRARY_PATH"
$ ./example

You can avoid the use of these environment variables by installing TileDB in a global (standard) location on your system, or hard-coding the path to the TileDB library at build time by configuring the rpath, e.g.

$ g++ -std=c++17 example.cpp -o example \
     -I<path/to/TileDB>/include \
     -L<path/to/TileDB>/lib \
     -Wl,-rpath,<path/to/TileDB>/lib \
     -ltiledb

Building your program this way will result in a binary that will run without having to configure the LD_LIBRARY_PATH or DYLD_LIBRARY_PATH environment variables.

Alternatively, when installing to system-wide paths known to ldconfig (typically in /etc/ld.so.conf.d/* or /etc/ld.so.conf ), run sudo ldconfig after installation to update the search cache.

To use TileDB from a Visual Studio C++ project, you need to add project properties telling the compiler and linker where to find the headers and libraries.

Open your project’s Property Pages. Under the General options for C/C++, edit the “Additional Include Directories” property. Add a new entry pointing to your TileDB installation (either built from source or extracted from the binary release .zip file), e.g. C:\path\to\TileDB\dist\include.

Under the General options for the Linker, edit the “Additional Library Directories” property. Add a new entry pointing to your TileDB installation, e.g. C:\path\to\TileDB\dist\lib. Under the Input options for Linker, edit “Additional Dependencies” and add tiledb.lib.

You should now be able to add #include <tiledb/tiledb.h> (C API) or #include <tiledb/tiledb> (C++ API) in your project.

At runtime, the directory containing the DLLs must be in your PATH environment variable, or you will see error messages at startup that the TileDB library or its dependencies could not be located. You can do this in Visual Studio by adding PATH=C:\path\to\TileDB\dist\bin to the “Environment” setting under “Debugging” in the Property Pages. You can also do this from the Windows Control Panel, or at the command prompt like so:

> $env:Path += ";C:\path\to\TileDB\dist\bin"
> my_program.exe

> set PATH=%PATH%;C:\path\to\TileDB\dist\bin
> my_program.exe

TileDB includes support for CMake’s find_package(). To use, TileDB must be installed globally or CMAKE_PREFIX_PATH must be set to the TileDB installation directory.

For example if TileDB was built with ../bootstrap and no prefix was given then the </path/to/TileDB>/dist/lib/cmake/TileDB directory will contain the TileDBConfig.cmake file used for find_package(TileDB). In your project, you would set CMAKE_PREFIX_PATH like so:

list(APPEND CMAKE_PREFIX_PATH "</path/to/TileDB>/dist")

You can also pass this like any other CMake variable on the command line when configuring your project, e.g.

$ cmake -DCMAKE_PREFIX_PATH=</path/to/TileDB>/dist ..

To link the executable MyExe in your project with the TileDB shared library, you would then use:

# Find TileDB
find_package(TileDB REQUIRED)
# Link to shared library, this will set header include directories also.
target_link_libraries(MyExe PRIVATE TileDB::tiledb_shared)

While disabled by default, TileDB can also be built as a static library. To do this, use the --enable-static-tiledb (macOS/Linux) or -EnableStaticTileDB (Windows) bootstrap flag when configuring TileDB, or use the CMake equivalent flag -DTILEDB_STATIC=ON. Then in your project simply link against the tiledb_static target instead:

# Find TileDB
find_package(TileDB REQUIRED)
# Link to static library, this will set header include directories also
target_link_libraries(MyExe PRIVATE TileDB::tiledb_static)

You can see the example CMake project in the TileDB source repository to see an example project structure that links against TileDB.

Begin by downloading a release tarball or by cloning the TileDB GitHub repo and checking out a release tag (where <version> is the version you wish to use (e.g., 1.7.4)

$ git clone https://github.com/TileDB-Inc/TileDB.git
$ cd TileDB
$ git checkout <version>

To configure TileDB, use the bootstrap script:

$ mkdir build
$ cd build
$ ../bootstrap <flags>
$ # Or use CMake directly instead of bootstrap:
$ # cmake <flags> ..

The flags for the bootstrap script and the CMake equivalents are as follows:

To build after configuration, run the generated make script

$ make -j <nprocs>

To install to the configured prefix

$ make install-tiledb

Note that building against the installed shared library requires setting the library search path at build- or run-time, as documented in Usage. (system-wide installations requiring sudo permissions may avoid this step by running sudo ldconfig after installation).

Other helpful makefile targets:

# Runs the tests
make check

# Builds the examples
make examples

Building TileDB on Windows has been tested to work with Microsoft Visual Studio 2019 and later. You can install the free Community Edition if you’d like the full IDE, or the Build Tools if you don’t need or want the IDE installed.

During the Visual Studio setup process, make sure the Git for Windows component is selected if you do not already have a working Git installation. Also be sure to select the CMake component if you do not have a working CMake installation.

In addition, you will need to install PowerShell (free).

To build and install TileDB, first open PowerShell and clone the TileDB repository and checking out a release tag (where <version> is the version you wish to use (e.g., 1.7.4)

> git clone https://github.com/TileDB-Inc/TileDB.git
> cd TileDB
> git checkout <version>

Next, ensure the CMake binaries are in your path. If you installed Visual Studio, execute

> $env:Path += ";C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\Common7\IDE\CommonExtensions\Microsoft\CMake\CMake\bin"
> # If you installed the build tools, instead execute:
> # $env:Path += ";C:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\Common7\IDE\CommonExtensions\Microsoft\CMake\CMake\bin"

Create a build directory and configure TileDB

> mkdir build
> cd build
> ..\bootstrap.ps1 <flags>
> # Or use CMake directly:
> # cmake <flags> ..

The flags for the bootstrap script and the CMake equivalents are as follows:

To build after configuration

> cmake --build . --config Release

To install

> cmake --build . --target install-tiledb --config Release

Other helpful build targets:

# Runs the tests
cmake --build . --target check --config Release

# Builds the examples
cmake --build . --target examples --config Release

Cygwin is a Unix like environment and command line interface for Microsoft Windows that provides a large collection of GNU / OpenSource tools (including the gcc toolchain) and supporting libraries that provide substantial POSIX API functionality. TileDB is able to compile from source in the Cygwin environment if Intel TBB is disabled and some TileDB dependencies are installed as Cygwin packages.

The following Cygwin packages need to be installed:

• gcc / g++

• git

• cmake

• make

• lz4-devel

• zlib-devel

• libzstd-devel (+src)

• bzip2 (+src)

• openssl-devel

You can then clone and build TileDB using git / cmake / make:

$ git clone https://github.com/TileDB-Inc/TileDB.git
$ cd TileDB
$ git checkout <version>
$ mkdir build && cd build
$ cmake -DTILEDB_TBB=OFF ..
$ make
$ make check