GraalVM

GraalVM is a really powerful technology that is being used in certain departments of my organization. This allows us to pre-compile Java programs and helps us to speed up the processes by using minimal resources. This is highly maintainable and easy to use for Java developers. This helps us in deploying more container services with the same hardware.

GraalVM is a high-performer runtime that provides significant improvements in application performance and efficiency which is a deal for microservices. [It's] designed for application writing in Java, JavaScript, LLVM-based languages such as C and C++. It helps to do away with isolation between programming languages and enables interoperability in a shared runtime. I love that it can run either standalone or in the context of OpenJDK,Node.js or Oracle Database.

An amazing tool that is being used in my organization to streamline Java Applications. Some of the departments are utilizing this to address the problems with the Interface of Native Java. This integrates easily with our existing applications and makes them convenient to use. This consumes [fewer] resources which makes our processes more efficient.

GraalVM is being used in multiple departments of my organization by the dev teams. It is a high-performance tool that helps us to speed up the processes [while] consuming very few resources. It is easily maintainable and very flexible. This has seamless integration which makes our applications very efficient.

We are currently trying to move our infrastructure to Spring Boot, so with the recent additions of Spring Native, I got interested in Graal VM, and found it fascinating. It provides the opportunity to make tiny docker containers which provide the ability to lower cloud hosting pricing.

GraalVM is a powerful tool created by Oracle that was being used by the dev team in our organization. It is a high-performance Java Virtual Machine that also provides the Java Development Kit i.e JDK that has the ability to compile the Java applications ahead of time. Also, it helps in increasing the overall performance of the application since it consumes very fewer resources. The maintenance of the product is quite easy and it is quite flexible since it is written in Java.

This is among the most robust and user-friendly applications that are being used in certain departments of our company. This is being used to streamline the JAVA codes and test them as well. This has seamless integration with our existing applications which makes the usage very efficient. Also, the cost of deployment is comparatively less resulting in cost savings.

GraalVM is used by the department where Java applications are used the most, this software provides significant performance benefits. It also provides a security patch against the already known vulnerabilities. It helps in optimizing the Java performance and helps in cloud-native app development.

In my company, we use GraalVM as an engine for our APIs developed in Quarkus. We decided to use this tool to reduce our costs with scaling virtual machines, which with the common JVM required a lot of RAM. So far we have not had any disadvantages with using GraalVM. All our new applications are being written in a framework with native support for it. And our legacy applications are gradually being migrated to it as the community is growing and frameworks like Spring have started to receive support for GraalVM.

We use GraalVM Community Edition for JavaFX cross-platform app management on all major desktop platforms and iPadOS and Android. We aimed to optimize the outcome of the above using GraalVM Enterprise Edition. However, the attempt sadly failed due to licensing issues that surprisingly prevent GraalVM EE from being utilized like this. In my opinion, Oracle blocks its own business opportunities at this point. However, we continue using GraalVM EE in our boutique consulting company, informing German champions about the advantages of this amazing technology.

Just our department, we are exploring the possibility of using GraalVM to move old java applications on [the] cloud using the advantage of native compilation in order to reduce the workload and relative costs. Right now [applications] are written in spring and are quite [a] memory consuming (we use cloud stream messaging for processing [events] from Kafka).

I am an Indie developer and use GraalVM for daily development, mainly for replacing OpenJDK with it. [...] I use GraalVM to build other open-source projects that once use OpenJDK. [...]

It's really good. We are using [it] throughout the entire department. It really helps us to connect and use it across multiple languages and libraries. Our departments find it easy [to] compile applications using it with native binaries for you programmers out there. I would highly recommend it. It's easy to use and intuitive.

GraalVM is being used in selective teams as an alternate to traditional JVM. A primary usage is to optimize the application compilation using the ahead of time compilation feature. One more is usage of Truffle Language Implementation framework for other JVM-supported languages such as Groovy. All this has allowed us to reduce the startup time of mission-critical applications

We are using GraalVM in order to run some on-premises servers and to test part of our solutions. I'd say it's also a perfect tool to be used by Java developers. This tool usage made us reach a new step in terms of quality tests and brought us more options.

GraalVM is being used as a preferred virtual machine by Java developers at our organization to reduce the size of applications and loading time and to improve the cold-start time for achieving the best performance of applications with high efficiency while consuming fewer resources. It improves the capability of hardware to perform well with an increased number of applications. The developers using Python, Node.JS, C, and Oracle at our organization are also using it.

Our organization uses GraalVM to provide a standardized and optimized environment to run Java and Scala applications. This is used across departments for multiple enterprise Java solutions. GraalVM provides our organization with a Java development and deployment environment that is quick to set up for new developers and quick to configure for the deployment of new applications. With the performance enhancements that it provides, such as ahead-of-time compilation, we have found that GraalVM provides an optimum solution for running our enterprise Java applications effectively.

Exploring GraalVM for microservices-based, cloud native applications and serverless applications

We are in an investigative stage with GraalVM and AOT (native-compile) at the department level (software engineering and SecDevOps). We have deployed test applications written in Java and Scala to Windows, Ubuntu, and as Docker images running on container services (Google Cloud Run and Kubernetes).

At this point, I am very impressed. There was a learning curve to understand GraalVM, the polyglot features, and native-compiles. Pluralsight has a good fundamentals overview. The home site for GraalVM has a number of good "getting started" guides.

The areas that we are seeing major impacts in are software size, load time, and cold start time. These are critical benefits as we try to minimize the size of our containers and reduce cold-start time. The end result is more container services can be deployed with the same hardware. This could have a significant financial benefit over running code in a JVM.

We are also investigating the Polyglot features, such as running Node.js and Python in GraalVM. The ability to combine Java and Node.js could present some interesting features to combine the best of our libraries.

In my opinion, this product and technology will significantly improve the performance and footprint of Java-based containers to serverless containers, Kubernetes, and OpenShift.

We used Graal in a technical spike to cut down the footprint of Java stand-alone services that ran on a scheduled basis. It was a great success and brought us savings in memory and CPU footprint and improved startup times. In the long run, this will reduce infrastructure costs and improve platform resilience.

We have first decided to use GraalVM in our Innovation Department. Right now the decision process has started to allow usage of GraalVM as the production runtime in the whole company, since it has been proven that it suites our needs. We are using it mainly due to a multilingual approach adopted for the majority of our projects.

GraalVM is good technology. We are currently using it for building native images of iOS & Android applications. We have planned to have internal applications, which are developed on Java to be used with iOS and Android. GraalVM native images helps to build, package, and run those java applications on iOS and Android. We used GraalVM with Gluon package. Using Maven build tool we generated those apps. This software is used by our team of 15 members. We are in still the development phase, so it is limited to the team for internal usage. The problems that we are sorting out are managing daily work status, notifications, and publishing team events internally.

The organization has been recently expanding to game servers for Java games. The main issue with Java games is the lack of language interoperability with the default JVM, therefore other developers have a hard time working with them. But with GraalVM it allows almost seamless interoperability with other languages. LLVM-based languages ones especially are great with GraalVM.

GraalVM is being used by my organization to create a language-agnostic mod loader based on the Fabric API for Minecraft. It addresses a lot of problems with normal Java Native Interface Interop, and also makes it really easy to integrate numerous languages into the system.

The problem with normal JNIs is how hard it is to implement Mixins and other features, with GraalVM this is very easy and performant. GraalVM's performance is also outstanding, making it faster to launch dev environments and other factors.

Oracle GraalVM Enterprise Edition is being used in our organization across our project among a team of 45 members. It has majorly addressed the performance of applications by reducing the overhead in terms of startup time, execution time, and memory utilization. It provides additional advantages in writing applications in various programming languages.