Java News Roundup: NetBeans 25, Payara Platform, Hibernate Reactive, Gradle - Related to gradle, reactive, roundup:, stream, hugging

Hugging Face Models With Spring AI and Ollama Example

Ollama provides a lightweight way to run LLM models locally, and Spring AI enables seamless integration with AI models in Java applications. Let us delve into understanding Spring AI, Ollama, and Hugging Face models.

Ollama is a lightweight platform for running large language models (LLMs) locally on your machine. It provides a simple way to download and serve models such as Mistral, Llama, and others with minimal setup.

Local AI Processing: Run AI models on your system without relying on cloud services.

Fast and Efficient: Optimized for low-latency responses, making it ideal for real-time applications.

Easy Model Management: Download, revision, and switch between models seamlessly.

Privacy & Security: No data leaves your machine, ensuring a secure AI experience.

Chatbots: Deploy AI assistants that run locally for improved response time and privacy.

Content Generation: Use AI models to generate text, summarize content, or rewrite documents.

Embedding Generation: Generate high-quality embeddings for search and recommendation systems.

Testcontainers is a Java library that enables integration testing with real dependencies such as databases, message brokers, and application services by running them in lightweight, disposable Docker containers.

Reliable Integration Testing: Test with real databases and services instead of mocks or in-memory databases.

Lightweight & Disposable: Containers are spun up for tests and automatically removed afterward.

Parallel Execution: Each test instance can run in an isolated container, avoiding conflicts.

Easy CI/CD Integration: Works well in continuous integration pipelines without external dependencies.

Database Testing: Run PostgreSQL, MySQL, or MongoDB containers to test database interactions.

Microservices Testing: Simulate full-service dependencies for end-to-end testing.

AI Model Testing: Deploy AI models in a containerized environment for testing and validation.

By combining Ollama with Testcontainers, developers can easily set up AI-driven applications with real-world testing scenarios, ensuring reliability and scalability.

To use Spring AI with Ollama on TestContainers, add the required dependencies in your [website] file.

[website] spring-ai-ollama-spring-boot-starter [website] org.testcontainers testcontainers [website] test.

[website] Setting up Ollama With Testcontainers.

To start an Ollama container using Testcontainers, add the following configuration in a test class:

import [website]; import org.testcontainers.containers.GenericContainer; public class OllamaContainerTest { private static GenericContainer ollamaContainer; @BeforeAll static void startContainer() { ollamaContainer = new GenericContainer("ollama/ollama:latest") .withExposedPorts(11434) .withCommand("serve"); [website]; } }.

The given Java code defines a test class, OllamaContainerTest , which uses Testcontainers to run an Ollama container for testing purposes. It declares a GenericContainer instance named ollamaContainer , which is initialized in the startContainer() method annotated with @BeforeAll , meaning it runs once before all tests. The container is configured to use the ollama/ollama:latest image, expose port 11434 , and execute the serve command upon startup. When [website] is invoked, it pulls and runs the container, making the Ollama service available for integration testing.

Now, let’s integrate a Hugging Face model using Spring AI’s Ollama support.

import [website]; import [website]; import org.springframework.stereotype.Service; @Service public class ChatService { private final OllamaChatClient chatClient; public ChatService() { this.chatClient = new OllamaChatClient(new OllamaChatModel("mistral")); } public String chatWithModel(String prompt) { return [website]; } }.

The given Java code defines a Spring Boot service class named ChatService , which integrates with the Ollama AI model using Spring AI . It imports OllamaChatClient and OllamaChatModel from the Spring AI Ollama package and is annotated with @Service , making it a Spring-managed bean. The constructor initializes the chatClient by creating a new instance of OllamaChatClient with the OllamaChatModel set to “mistral”. The method chatWithModel(String prompt) takes a user prompt as input, sends it to the chat model, and returns the generated response using [website] . This service acts as an interface to interact with the AI model and generate responses based on user queries.

Create an API endpoint to invoke the model and receive a response based on the given prompt.

import [website]; import [website]; import [website]; @RestController public class ChatController { private final ChatService chatService; public ChatController(ChatService chatService) { this.chatService = chatService; } @GetMapping("/chat") public String chat(@RequestParam String prompt) { return chatService.chatWithModel(prompt); } }.

The given Java code defines a Spring Boot REST controller named ChatController that provides an API endpoint for interacting with the AI model. It is annotated with @RestController , indicating that it handles HTTP requests and returns JSON responses. The class has a dependency on ChatService , which is injected via constructor-based dependency injection. The method chat(@RequestParam String prompt) is mapped to the /chat endpoint using @GetMapping . When a user sends a GET request with a prompt parameter, it calls the chatWithModel method from ChatService and returns the generated response from the AI model. This controller acts as an interface for clients to interact with the AI chatbot via HTTP requests.

When the Spring Boot application is started and the /chat endpoint is triggered, the following output is returned.

{ "response": "Hello! How can I assist you today?" }.

To generate embeddings, use the following service:

import [website]; import [website]; import org.springframework.stereotype.Service; import [website]; @Service public class EmbeddingService { private final OllamaEmbeddingClient embeddingClient; public EmbeddingService() { this.embeddingClient = new OllamaEmbeddingClient(new OllamaEmbeddingModel("all-MiniLM-L6-v2")); } public List getEmbedding(String text) { return [website]; } }.

The given Java code defines a Spring Boot service class named EmbeddingService , which is responsible for generating embeddings from text using the Ollama AI model. Annotated with @Service , it is a Spring-managed component that can be injected into other parts of the application. The class initializes an instance of OllamaEmbeddingClient with the OllamaEmbeddingModel set to "all-MiniLM-L6-v2" , a commonly used model for text embeddings. The method getEmbedding(String text) takes a text input, processes it through the embedding client, and returns a list of floating-point values representing the text’s embedding vector. This service enables applications to generate numerical representations of text, useful for tasks such as semantic search, similarity comparisons, and natural language processing tasks.

If, for any reason, the model fails to return a response ([website], the LLM model returns null), a 500 HTTP error ( Internal Server Error ) is thrown. However in most cases a default value approach like below is adopted where if the embeddingResponse is null , an emptyList() is returned in the response. You can modify the above code like this:

var embeddingResponse = [website]; return (embeddingResponse != null && embeddingResponse.getEmbedding() != null) ? embeddingResponse.getEmbedding() : Collections.emptyList();

import [website]; import [website]; import [website]; import [website]; @RestController public class EmbeddingController { private final EmbeddingService embeddingService; public EmbeddingController(EmbeddingService embeddingService) { this.embeddingService = embeddingService; } @GetMapping("/embedding") public List getEmbedding(@RequestParam String text) { return embeddingService.getEmbedding(text); } }.

The given Java code defines a Spring Boot REST controller class named EmbeddingController , which provides an API endpoint for generating text embeddings. The class is annotated with @RestController , indicating it handles HTTP requests and returns JSON responses. It has a dependency on EmbeddingService , which is injected via constructor-based dependency injection. The method getEmbedding(@RequestParam String text) is mapped to the /embedding endpoint using @GetMapping . When a GET request is made with a text parameter, the method calls getEmbedding from EmbeddingService , generating and returning the embedding for the provided text as a list of floating-point values. This controller enables clients to access text embedding functionality via HTTP requests.

Redeploy and Spring boot application and once the /embedding?text=hello%20world endpoint is triggered, the following output is returned.

[[website], [website], [website], [website], [website]].

In this article, we explored integrating Hugging Face models with Spring AI and Ollama, covering topics such as setting up Ollama with Testcontainers, utilizing a chat completion model, and generating embeddings with an embedding model. These techniques enable seamless integration of advanced AI capabilities into Java applications, enhancing their functionality efficiently.

GitHub in recent times presented the public preview of Linux arm64 hosted runners for GitHub Actions. Free for public repositories, this improvement provides deve......

Docker has revealed the general availability of Docker Bake, a build orchestration tool designed to simplify complex Docker image builds. The Bake fu......

Working With Reactive Kafka Stream and Spring WebFlux

In modern application development, the need for real-time data processing and reactive programming has become increasingly critical. Reactive programming allows developers to build non-blocking, asynchronous, and event-driven applications that can handle a large number of concurrent requests with minimal resource consumption. Two popular technologies that enable reactive programming are Apache Kafka and Spring WebFlux. In the context of Java Spring WebFlux and Reactive Kafka, these tools provide a powerful combination for building scalable, real-time streaming applications. This article will explore how to work with Reactive Kafka Streams and Spring WebFlux.

Reactive programming is a programming paradigm that focuses on asynchronous data streams and the propagation of change. It is particularly well-suited for applications that need to handle a large number of concurrent requests, such as real-time data processing, IoT applications, and microservices architectures.

The key principles of reactive programming are:

Asynchronous : Operations are non-blocking and can execute independently of the main program flow.

: Operations are non-blocking and can execute independently of the main program flow. Event-driven : Applications react to events or changes in data, rather than polling or waiting for data to become available.

: Applications react to events or changes in data, rather than polling or waiting for data to become available. Backpressure: The ability to handle situations where the producer of data is faster than the consumer, ensuring that the consumer is not overwhelmed.

Reactive programming is often implemented using libraries such as Project Reactor (used by Spring WebFlux) or RxJava.

2. Overview of Apache Kafka and Kafka Streams.

Kafka Streams is a client library for building stream processing applications that transform, aggregate, and enrich data in real time. It allows us to process data streams using a high-level DSL (Domain Specific Language) or a lower-level Processor API.

Kafka Streams is tightly integrated with Kafka and provides aspects such as:

Stateful processing : Maintains state across multiple records, enabling operations like windowed aggregations and joins.

: Maintains state across multiple records, enabling operations like windowed aggregations and joins. Fault tolerance : Automatically handles failures and ensures exactly once processing semantics.

: Automatically handles failures and ensures exactly once processing semantics. Scalability: Scales horizontally by distributing processing across multiple instances.

Spring WebFlux is a reactive web framework that supports non-blocking, asynchronous programming. It is built on top of Project Reactor, which provides the reactive streams implementation. Spring WebFlux is designed to handle a large number of concurrent connections with minimal resource consumption, making it ideal for building reactive microservices and real-time applications.

Reactive Programming Model : Supports reactive streams and non-blocking I/O.

: Supports reactive streams and non-blocking I/O. Functional Programming : Allows us to define routes and handlers using functional programming constructs.

: Allows us to define routes and handlers using functional programming constructs. Integration with Reactive Libraries: Integrates with other reactive libraries such as Reactive Kafka, Reactive MongoDB, and more.

4. Setting Up a Reactive Kafka Stream with Spring WebFlux.

To get started with Reactive Kafka Streams and Spring WebFlux, we need to set up a Spring Boot project with the necessary dependencies. We can create a Spring Boot project using Spring Initializr or your favourite IDE. Add the following dependencies:

[website] spring-cloud-starter-stream-kafka [website] spring-boot-starter-webflux [website] spring-cloud-stream-binder-kafka-reactive.

In your [website] or application.properties file, configure the Kafka properties:

spring: kafka: bootstrap-servers: localhost:9092 consumer: group-id: my-group auto-offset-reset: earliest producer: key-serializer: [website] value-serializer: [website] properties: spring: json: trusted: packages: '*'

The above YAML configuration sets up Spring Kafka for the Spring Boot application, defining both producer and consumer properties. The bootstrap-servers field connects to a local Kafka broker at localhost:9092 . The consumer is assigned to "my-group" and starts reading messages from the earliest available offset. The producer uses String serialization for both keys and values to ensure proper message encoding. Additionally, [website] '*' allows deserialization from any package, enabling flexible JSON handling.

5. Building a Reactive Kafka Consumer with Spring WebFlux.

To build a reactive Kafka consumer, we can use the ReactiveKafkaConsumerTemplate provided by the Reactive Kafka library. Firstly, create a Kafka Consumer Configuration. Define a configuration class to initialize and set up the Kafka consumer, specifying properties such as the bootstrap servers, consumer group ID, key/value deserializers, and reactive Kafka settings.

@Configuration public class KafkaConsumerConfig { @Value("${[website]}") private String bootstrapServers; @Bean public ReceiverOptions receiverOptions() { Map props = new HashMap<>(); [website], bootstrapServers); [website], "my-group"); [website], [website]; [website], [website]; return [website]; } @Bean public ReactiveKafkaConsumerTemplate reactiveKafkaConsumerTemplate(ReceiverOptions receiverOptions) { return new ReactiveKafkaConsumerTemplate<>(receiverOptions); } }.

This configuration class sets up a reactive Kafka consumer using Reactor Kafka. The bootstrapServers field is injected with the Kafka broker address from [website] using @Value("${[website]}") . This allows the consumer to connect to the correct Kafka instance dynamically.

The receiverOptions() method creates a ReceiverOptions bean, which holds consumer configuration properties. These properties include the Kafka broker address, the consumer group ID ( "my-group" ), and deserializers ( [website] ) for both keys and values, ensuring that messages are properly converted from byte arrays to String format.

The reactiveKafkaConsumerTemplate() method defines a Reactive Kafka Consumer using ReactiveKafkaConsumerTemplate . This bean is built using the configured ReceiverOptions , allowing the application to consume Kafka messages reactively, supporting backpressure and non-blocking streaming.

[website] Create a Kafka Consumer Service.

[website] Expose the Kafka Consumer via a REST Endpoint.

Create a REST controller to expose the Kafka consumer:

@RestController @RequestMapping("/kafka") public class KafkaController { private final KafkaConsumerService kafkaConsumerService; public KafkaController(KafkaConsumerService kafkaConsumerService) { this.kafkaConsumerService = kafkaConsumerService; } @GetMapping(value = "/consume", produces = MediaType.TEXT_EVENT_STREAM_VALUE) public Flux consumeMessages() { return kafkaConsumerService.consumeMessages("my-topic"); } }.

6. Building a Reactive Kafka Producer with Spring WebFlux.

To build a reactive Kafka producer, we can use ReactiveKafkaProducerTemplate from the Reactive Kafka library, starting by defining a configuration class to set up the producer.

@Configuration public class KafkaProducerConfig { @Value("${[website]}") private String bootstrapServers; @Bean public SenderOptions senderOptions() { Map props = new HashMap<>(); [website], bootstrapServers); [website], [website]; [website], [website]; return [website]; } @Bean public ReactiveKafkaProducerTemplate reactiveKafkaProducerTemplate(SenderOptions senderOptions) { return new ReactiveKafkaProducerTemplate<>(senderOptions); } }.

This Kafka producer configuration class is responsible for setting up a reactive Kafka producer using ReactiveKafkaProducerTemplate . The bootstrapServers field is injected with the Kafka broker address from [website] using @Value("${[website]}") . This ensures that the producer dynamically connects to the configured Kafka instance without hardcoding the broker address.

The senderOptions() method creates and configures a SenderOptions bean, which defines key producer properties. The BOOTSTRAP_SERVERS_CONFIG property specifies the Kafka broker’s address, while KEY_SERIALIZER_CLASS_CONFIG and VALUE_SERIALIZER_CLASS_CONFIG are set to [website] , ensuring that both keys and values of messages are serialized as Strings before being sent to Kafka.

The reactiveKafkaProducerTemplate() method creates a ReactiveKafkaProducerTemplate bean, which is responsible for sending messages to Kafka in a reactive and non-blocking manner. This template is built using the configured SenderOptions , ensuring that all producer settings are applied.

[website] Create a Kafka Producer Service.

Create a service that produces messages to a Kafka topic:

@Service public class KafkaProducerService { private final ReactiveKafkaProducerTemplate reactiveKafkaProducerTemplate; public KafkaProducerService(ReactiveKafkaProducerTemplate reactiveKafkaProducerTemplate) { this.reactiveKafkaProducerTemplate = reactiveKafkaProducerTemplate; } public Mono sendMessage(String topic, String message) { return [website], message) .doOnSuccess(result -> [website]"Message sent successfully: " + message)) .doOnError(e -> [website]"Error sending message: " + e.getMessage())) .then(); } }.

This Kafka producer service is responsible for sending messages to a Kafka topic in a reactive and non-blocking manner using ReactiveKafkaProducerTemplate . The class injects an instance of ReactiveKafkaProducerTemplate through its constructor. The sendMessage(String topic, String message) method takes a Kafka topic and a message as parameters and returns a Mono , indicating an asynchronous operation that completes when the message is sent.

Inside the method, [website], message) sends the message to Kafka. The doOnSuccess(result -> [website] callback logs a success message when the message is published, while doOnError(e -> [website] logs any errors that occur during the process. The .then() ensures that the method returns a Mono , meaning it does not emit any value but simply signals completion or error.

[website] Expose the Kafka Producer via a REST Endpoint.

Create a REST controller to expose the Kafka producer:

@RestController @RequestMapping("/kafka") public class KafkaController { private final KafkaProducerService kafkaProducerService; public KafkaController(KafkaProducerService kafkaProducerService) { this.kafkaProducerService = kafkaProducerService; } @PostMapping("/produce") public Mono produceMessage(@RequestParam String message) { return kafkaProducerService.sendMessage("my-topic", message); } }.

This Kafka controller exposes an endpoint for producing messages to a Kafka topic. The controller injects an instance of KafkaProducerService through its constructor, ensuring that it can access the reactive Kafka producer for sending messages. The produceMessage(@RequestParam String message) method is mapped to a POST request at /kafka/produce , allowing clients to send messages via an HTTP request. It takes a message as a request parameter and calls kafkaProducerService.sendMessage("my-topic", message) , which asynchronously sends the message to Kafka.

Since the method returns a Mono , it follows reactive principles, meaning the request completes when the message is successfully sent or an error occurs. This non-blocking approach ensures that the API can handle multiple requests efficiently.

To test the consumer with a specific topic, you need to ensure the topic exists in your Kafka broker. You can create a Kafka topic manually using the [website] script provided by Kafka. If you have Kafka installed locally, navigate to the Kafka bin directory and use the [website] script to create a new topic. For example, to create a topic named my-topic with 1 partition and a replication factor of 1:

./[website] --create --topic my-topic --bootstrap-server localhost:9092 --partitions 1 --replication-factor 1.

You can verify that the topic was created successfully by listing all topics:

./[website] --list --bootstrap-server localhost:9092.

You should see my-topic in the list of topics.

Open a terminal and run the following curl command to consume messages from a specific topic ([website], my-topic ):

curl -N "[website]:8080/kafka/consume?topic=my-topic"

Open another terminal and send messages to the my-topic topic using the producer endpoint:

curl -X POST "[website]:8080/kafka/produce?message=TestMessage1&topic=my-topic" curl -X POST "[website]:8080/kafka/produce?message=TestMessage2&topic=my-topic"

In the first terminal (where the consumer is running), you should see the messages appear in real-time:

8. Handling Backpressure in Reactive Kafka Streams.

Backpressure is a critical concept in reactive programming, where the consumer needs to control the rate at which it receives data from the producer to avoid being overwhelmed. In the context of Kafka, backpressure can be handled using the onBackpressureBuffer , onBackpressureDrop , or onBackpressureLatest operators provided by Project Reactor.

For example, we can apply backpressure to the Kafka consumer as follows:

public Flux consumeMessages(String topic) { return reactiveKafkaConsumerTemplate .receiveAutoAck() .doOnNext(record -> [website]"Received message: " + [website] .map(ConsumerRecord::value) .onBackpressureBuffer(1000) // Buffer up to 1000 messages .onErrorResume(e -> { [website]"Error consuming message: " + e.getMessage()); return [website]; }); }.

In a reactive Kafka stream, it is essential to handle errors gracefully and implement retry mechanisms to ensure the reliability of the application.

We can handle errors using the onErrorResume or onErrorContinue operators:

public Flux consumeMessages(String topic) { return reactiveKafkaConsumerTemplate .receiveAutoAck() .doOnNext(record -> [website]"Received message: " + [website] .map(ConsumerRecord::value) .onErrorResume(e -> { [website]"Error consuming message: " + e.getMessage()); return [website]; }); }.

We can implement a retry mechanism using the retry or retryWhen operators:

public Flux consumeMessages(String topic) { return reactiveKafkaConsumerTemplate .receiveAutoAck() .doOnNext(record -> [website]"Received message: " + [website] .map(ConsumerRecord::value) .retryWhen(Retry.backoff(3, Duration.ofSeconds(1))) .onErrorResume(e -> { [website]"Error consuming message: " + e.getMessage()); return [website]; }); }.

In this article, we explored how to work with Reactive Kafka Streams and Java Spring WebFlux to build a reactive, real-time data processing application. We covered the basics of reactive programming, Kafka, and Spring WebFlux, and demonstrated how to set up a reactive Kafka consumer and producer. By leveraging the power of reactive programming, we can build highly scalable and efficient applications that can handle large volumes of data in real-time. With the combination of Kafka and Spring WebFlux, we can create event-driven systems that are well-suited for modern application development.

This article covered integrating Java Spring WebFlux with Reactive Kafka Streams.

Adam’s such a mad scientist with CSS. He’s been putting together a series of “notebooks” that make it easy for him to demo code. He’s got one for grad......

La version de février de CMake Tools est arrivée sur Visual Studio Code. CMake Tools supporte Cmake Language Services. Il s'agit d'une intégration plu......

GitHub lately revealed the public preview of Linux arm64 hosted runners for GitHub Actions. Free for public repositories, this modification provides deve......

Java News Roundup: NetBeans 25, Payara Platform, Hibernate Reactive, Gradle

This week's Java roundup for February 17th, 2025 aspects news highlighting: the release of Apache NetBeans 25; the February 2025 release of the Payara Platform; the second beta release of Hibernate Reactive [website]; and the second release candidate of Gradle [website].

Build 36 remains the current build in the JDK 24 early-access builds. Further details may be found in the release notes.

Build 11 of the JDK 25 early-access builds was also made available this past week featuring updates from Build 10 that include fixes for various issues. More details on this release may be found in the release notes.

For JDK 24 and JDK 25, developers are encouraged to analysis bugs via the Java Bug Database.

It was a busy week over at Spring as the various teams have delivered milestone releases of Spring Boot, Spring Security, Spring Authorization Server, Spring Integration, Spring AI and Spring AMQP. There were also point releases of Spring Framework, Spring for GraphQL,Spring Session, Spring for Apache Kafka and Spring for Apache Pulsar. Further details may be found in this InfoQ news story.

Payara has released their February 2025 edition of the Payara Platform that includes Community Edition [website], Enterprise Edition [website] and Enterprise Edition [website] All three releases provide critical bug fixes, component upgrades and a new feature that ensures Docker images shutdown gracefully to allow applications to cleanly terminate without data loss or corruption.

A notable critical issue was an IllegalStateException due to Spring Boot 3 applications failing to deploy to Payara Server 6. This was resolved by ensuring proper initialization of Contexts and Dependency Injection (CDI) during deployment. More details on these releases may be found in the release notes for Community Edition [website] and Enterprise Edition [website] and Enterprise Edition [website].

The release of Apache NetBeans 25 delivers many improvements that include: enhancements in support for Java code completion for sealed types in switch statements; improved behaviour with the CloneableEditorSupport class such that it will no longer break additional instances of the Java DocumentFilter class which may be attached to an instance of the Java AbstractDocument class. Further details on this release may be found in the release notes.

The release of Apache Tomcat [website] provides a resolution to a regression with the release of Tomcat [website] that caused an error while starting Tomcat on JDK 17. The regression was a mitigation for CVE-2024-56337, a Time-of-Check-Time-of-Use vulnerability in which a write-enabled default servlet for a case insensitive file system can bypass Tomcat’s case sensitivity checks and cause an uploaded file to be treated as a JSP leading to a remote code execution. More details on this release may be found in the release notes.

The second beta release of Hibernate Reactive [website] ships with resolutions to notable issue such as: a ClassCastException from an instance of the ReactiveEmbeddableForeignKeyResultImpl class due to use of the Hibernate ORM EmbeddableInitializerImpl class instead of its reactive version, namely the ReactiveEmbeddableInitializerImpl class; and a NullPointerException when retrieving an entity using a Jakarta Persistence @ManyToOne composite table with additional properties in the Jakarta Persistence @IdClass annotation. This release is compatible with Hibernate ORM [website], and an upgrade to [website] SQL client [website] Further details on this release may be found in the changelog.

The release of JobRunr [website] ships with bug fixes and new attributes such as: the ability to switch between different date styles in job table views, [website], the timestamp when an instance of the Job class was enqueued; and an enhanced display for more complex job parameters on the job details page. More details on this release may be found in the release notes.

The second release candidate of Gradle [website] introduces a new auto-provisioning utility that automatically downloads a JVM required by the Gradle Daemon. Other notable enhancements include: an explicit Scala version configuration for the Scala Plugin to automatically resolve required Scala toolchain dependencies; and refined millisecond precision in JUnit XML test event timestamps. Further details on this release may be found in the release notes.

Shell scripting is a powerful tool for automation, system administration, and software deployment. However, as your shell scripts grow in size and com......

Look Closer, Inspiration Lies Everywhere (February 2025 Wallpapers Edition).