Which package?

Two packages give you the ArcadeDB engine inside your Python process. Both use the import name arcadedb, and they have the same public API. Install one of them, not both.

Package Engine Pick it for

Package	Engine	Pick it for
`arcadedb` (the default)	The native build. The engine is compiled by GraalVM Community Edition into a shared library, which Python loads with `ctypes`. No JVM, no JPype, no bundled Java runtime.	Embedded use in scripts, notebooks, tests, CLIs, serverless functions and agents. It starts fast and holds little memory, because there is no JVM.
`arcadedb-jvm`	The JVM build. The Java engine runs in your process through JPype, on a bundled Java 25 runtime.	Heavy, long-running loads, where the JIT compiler makes the engine faster over time. Also the Java-object APIs (`get_java_database` and similar), JVM options, `jvm_kwargs` and `start_jvm`.

arcadedb (the default)

The native build. The engine is compiled by GraalVM Community Edition into a shared library, which Python loads with ctypes. No JVM, no JPype, no bundled Java runtime.

Embedded use in scripts, notebooks, tests, CLIs, serverless functions and agents. It starts fast and holds little memory, because there is no JVM.

arcadedb-jvm

The JVM build. The Java engine runs in your process through JPype, on a bundled Java 25 runtime.

Heavy, long-running loads, where the JIT compiler makes the engine faster over time. Also the Java-object APIs (get_java_database and similar), JVM options, jvm_kwargs and start_jvm.

pip install arcadedb     # native, the default
pip install arcadedb-jvm        # JVM, for heavy long-running loads

If you are not sure, install arcadedb. You can switch later: your code does not change (see Switch from one to the other).

Transition note. The first release of this layout is 26.11.1. Until the native build passes its readiness bar, arcadedb may appear only as pre-releases, 26.11.1.devN. Until a final 26.11.1 exists, PyPI holds only these pre-releases, and a plain pip install arcadedb or uv add arcadedb installs the newest one. After a final release, a plain install takes the final, and a later pre-release needs pip install --pre arcadedb (or uv add --prerelease allow arcadedb). The same holds for arcadedb-jvm. The readiness bar is listed in Release.

Check which one you have

python -c "import arcadedb; print(arcadedb.__backend__)"

It prints native or jvm. You can also ask pip:

pip show arcadedb arcadedb-jvm

pip show prints a block for each package that is installed, and a warning for the one that is not. In a correct environment exactly one of the two is installed.

What changes between them

The API is the same. The runtime is not. These are the differences you can plan for.

arcadedb (native) arcadedb-jvm (JVM)

	`arcadedb` (native)	`arcadedb-jvm` (JVM)
Start-up	Fast. There is no JVM to start.	Slower. Every Python process starts a JVM first.
Memory	Small footprint.	Larger. The JVM keeps a heap, and each Python process starts its own JVM.
Garbage collector	The serial collector of GraalVM Community Edition. A collection stops all threads, and the pause grows with the live data. The heap limit is 50% of the memory by default (Heap size).	The JVM’s own collectors, G1 by default on a server-class machine. You choose them and the heap with `jvm_kwargs` (JVM options).
Throughput on long loads	No JIT warm-up. Speed over a long run depends on the workload.	The JIT compiler makes long-running loads faster over time.
Speed on your data	Measure on your own workload.	Measure on your own workload.
Wheel size	Smaller. It carries no Java runtime.	Larger. It carries a Java 25 runtime for its platform.
Python versions	3.11 to 3.15. On 3.15 the CI runs a subset of the tests.	3.11 to 3.14. JPype has no 3.15 wheel yet, so pip refuses the package on 3.15.
Platforms	Linux x86_64 and aarch64 (glibc 2.28 or later), macOS arm64, Windows x64. The Windows wheel is the newest: it is built in CI, and its test run is the least proven of the four. Not built: Intel Mac, Alpine (musl), Windows on ARM. See Requirements.	Linux x86_64 and aarch64 (glibc 2.28 or later), macOS arm64, Windows x64. Not built: Intel Mac, Alpine (musl), Windows on ARM.
Java-object APIs (`get_java_database`, `get_java_document`, `get_java_*`)	Not available. They raise `NotOnNativeYet`.	Available.
JVM options (`jvm_kwargs`, `start_jvm`, `-X` and `-D` flags)	Do not exist. There is no JVM.	Available. See JVM options.
A few API calls	None, except the Java-object calls above, which raise `NotOnNativeYet` (a `NotImplementedError`).	Work.

Start-up

Fast. There is no JVM to start.

Slower. Every Python process starts a JVM first.

Memory

Small footprint.

Larger. The JVM keeps a heap, and each Python process starts its own JVM.

Garbage collector

The serial collector of GraalVM Community Edition. A collection stops all threads, and the pause grows with the live data. The heap limit is 50% of the memory by default (Heap size).

The JVM’s own collectors, G1 by default on a server-class machine. You choose them and the heap with jvm_kwargs (JVM options).

Throughput on long loads

No JIT warm-up. Speed over a long run depends on the workload.

The JIT compiler makes long-running loads faster over time.

Speed on your data

Measure on your own workload.

Wheel size

Smaller. It carries no Java runtime.

Larger. It carries a Java 25 runtime for its platform.

Python versions

3.11 to 3.15. On 3.15 the CI runs a subset of the tests.

3.11 to 3.14. JPype has no 3.15 wheel yet, so pip refuses the package on 3.15.

Platforms

Linux x86_64 and aarch64 (glibc 2.28 or later), macOS arm64, Windows x64. The Windows wheel is the newest: it is built in CI, and its test run is the least proven of the four. Not built: Intel Mac, Alpine (musl), Windows on ARM. See Requirements.

Linux x86_64 and aarch64 (glibc 2.28 or later), macOS arm64, Windows x64. Not built: Intel Mac, Alpine (musl), Windows on ARM.

Java-object APIs (get_java_database, get_java_document, get_java_*)

Not available. They raise NotOnNativeYet.

Available.

JVM options (jvm_kwargs, start_jvm, -X and -D flags)

Do not exist. There is no JVM.

Available. See JVM options.

A few API calls

None, except the Java-object calls above, which raise NotOnNativeYet (a NotImplementedError).

Work.

Both packages run the same ArcadeDB engine, with the same SQL and openCypher and the same database format.

Switch from one to the other

The two wheels refuse to work together. If both are installed, import arcadedb raises an ImportError that names both packages. The reason is that both wheels write into the same arcadedb directory, and pip would overwrite files of one with files of the other without a message. So remove both and install the one you want:

pip uninstall arcadedb arcadedb-jvm
pip install arcadedb-jvm

There is no extra to select a build: arcadedb[jvm] does not exist. Your code stays as it is, because both import as arcadedb. Only code that uses a JVM-only API (see the table above) needs a change when you move to the native build.

Server use

Neither package is a server deployment. They embed the engine in one Python process. For HTTP access, Studio, many processes, other programming languages or high availability, run the official Docker image arcadedata/arcadedb and connect with a driver (see Packages that talk to a server). The Embedded bindings or the HTTP driver section compares the two ways.

Old names

The packages had other names until 26.10.x. Search results and old tutorials may still use them.

New package Old name Note

New package	Old name	Note
`arcadedb-jvm`	Formerly `arcadedb-embedded`, imported as `arcadedb_embedded`	The same JVM build, with the import name `arcadedb`. The last release of the project formerly `arcadedb-embedded` (26.11.1) will be a deprecation shim that installs `arcadedb`, the native build, and warns. If you need the JVM build, install `arcadedb-jvm` yourself.
`arcadedb`	Formerly `arcadedb-embedded-native`, imported as `arcadedb_native`	The same build, now with the import name `arcadedb`. The old preview versions were 26.10.x pre-releases. The old project is archived on PyPI: no new releases and no shim.

arcadedb-jvm

Formerly arcadedb-embedded, imported as arcadedb_embedded

The same JVM build, with the import name arcadedb. The last release of the project formerly arcadedb-embedded (26.11.1) will be a deprecation shim that installs arcadedb, the native build, and warns. If you need the JVM build, install arcadedb-jvm yourself.

arcadedb

Formerly arcadedb-embedded-native, imported as arcadedb_native

The same build, now with the import name arcadedb. The old preview versions were 26.10.x pre-releases. The old project is archived on PyPI: no new releases and no shim.

Migrate from the old names

Remove the old package: pip uninstall arcadedb-embedded arcadedb-embedded-native.
Install the new one: pip install arcadedb-jvm if you used arcadedb-embedded, or pip install arcadedb if you used arcadedb-embedded-native. Add --pre while the transition note above applies.
Change the import: import arcadedb_embedded and import arcadedb_native both become import arcadedb. The builds are the same as in the table above, so the rest of your code stays.

Releases of the new layout start with 26.11.1. The 26.10.x wheels were built in a separate repository of the humemai organisation.

Packages that talk to a server

None of these contains the engine. They connect to a running ArcadeDB server.

arcadedb-driver: the official HTTP client. See Python — HTTP driver.
arcadedb-driver-grpc: the official gRPC client. See Python — gRPC driver.
arcadedb-python: a community HTTP driver by Steve Reiner and others (stevereiner/arcadedb-python). It is not related to this repository, whose name is also arcadedb-python. Check which one a tutorial installs before you copy its code.