---
description: Getting started with the official IOTA Client Library Java binding.
image: /img/logo/iota_mark_light.png
keywords:
- Java
- Rust
- jar
- maven
- environment variable
---
import PasswordStorage from "../../_admonitions/_password_storage.md";
import CompilingForAndroid from "../../_admonitions/_compiling_for_android.md";
# Getting Started
## Prerequisites
To use the library, we recommend you update Rust to the latest stable version [`$ rustup update stable`](https://github.com/rust-lang/rustup.rs#keeping-rust-up-to-date). Nightly should be fine but some changes might not be compatible.
Ensure you have first installed the required dependencies for the library [here](https://github.com/iotaledger/iota.rs/blob/dev/README.md). Then also install the following programs:
- Java & JDK (Make sure $JAVA_HOME env variable) is set
- [Gradle](https://gradle.org/install/) v4 or higher or [Maven](https://maven.apache.org/download.cgi) installe
- Cargo ndk (`cargo install cargo-ndk`)
- Cargo fmt (`rustup component add rustfmt`)
Download or clone the `iota.rs` repository
```bash
git clone https://github.com/iotaledger/iota.rs.git
```
## Security
<PasswordStorage />
## Installation
To build using the iota.rs Java bindings, you need the following two parts:
1. JNI Native library linking `Rust` to `C`, and then `C` to java `native` methods (`.so` , `.dll` or `.dylib` depending on your system).
2. Java archive(Jar) containing `native` methods which call C code. (`.jar`).
### Step 1: Creating the Native Library
Build the iota.rs library (This generates the java source code and JNI library file)
```bash
cd iota.rs/bindings/java
cargo build --release
```
Generated binaries can then be found at `iota.rs/bindings/java/target/release`
<CompilingForAndroid />
### Step 2: Creating the Java archive
#### Generating the source files and classes
After step 1, Java source files will be generated under `iota.rs/bindings/java/native/src/main/java/org/iota/client`.
If this step succeeded, we need to generate the jar file containing the newly generated Java source files.
#### Generating the jar
Generating the jar can be done with your tool of preference. We provide examples for Gradle and Maven in this guide
##### Gradle
Make `gradlew` executable (`chmod +x gradlew`) if needed, then run
```bash
cd iota.rs/bindings/java
./gradlew jar
```
##### Maven
```bash
cd iota.rs/bindings/java
mvn install
```
After running one of these commands, the jar can then be found at `iota.rs/bindings/java/native/build/libs/native.jar`
## Usage
You can find more information on using the `iota.rs` library's java binding in the [examples section](./../../examples/running_examples.mdx).
### Gradle
```bash
./gradlew examples:java-app:test --info
```
### Maven
```bash
mvn exec:exec
```
## Initialisation
This example fetches node information
```java
private static void nodeInfo() {
String nodeUrl = "https://chrysalis-nodes.iota.cafe:443";
Client iota = Client.Builder()
// Insert your node URL here
.withNode(nodeUrl)
// Choose pow mode
.withLocalPow(true)
//Then create the Client instance
.finish();
NodeInfoWrapper info = iota.getInfo();
System.out.println("Node url: " + info.url());
System.out.println("Node Info: " + info.nodeInfo());
}
```
## API Reference
Java
### Limitations
Due to the fact that we are linking through C from Rust, there are a couple of limiting factors.
- Classic builder patterns return a `clone` after each builder call since we can only pass back to C by reference in `Rust`
```Java
Builder builder1 = new Builder();
Builder builder2 = builder1.setValue(true);
// These are different instances, thus builder1 wont have the value set
assertNotEquals(builder1, builder2);
```