Leaving a video review helps other professionals like you evaluate products. Be the first one in your network to record a review of GraalVM, and make your voice heard!
Entry-level set up fee?
- Setup fee optional
- Free Trial
- Free/Freemium Version
- Premium Consulting / Integration Services
Would you like us to let the vendor know that you want pricing?
GraalVM Community is available for free for any use.
GraalVM Enterprise provides additional performance, security, and scalability relevant for running applications in production. Users can get a version of GraalVM Enterprise that is free for evaluation and developing new applications via the Oracle Technology Network (OTN), or a commercially licensed version for production use via the Oracle Store.
|Deployment Types||On-premise, SaaS|
|Operating Systems||Windows, Linux, Mac|
- Reduction of application size.
- This supports Java 111.
- Hardware requirements have reduced because of this.
- Minimal consumption of resources.
- Documentation needs to be improved and in a proper manner.
- Support of Micro services needs to be enhanced.
- Customer Support Service is not up to the mark.
- Run Java Faster, GraalVM can run in the context of OpenJDK to make Java applications run faster with a new just-in-time compilation technology.
- Create a Native Image, running [an] application inside a Java VM comes with startup and footprint costs.
- Documentation is not that well detailed up to date.
- The customer support is not always available.
- It is easily maintainable.
- Requires minimal resources which results in low memory utilization.
- Supports Java 11 for better performance.
- Easily configurable.
- No proper documentation present.
- Few JDK versions are not supported currently.
- Customer support is not at par with the industry standards.
- This supports Java 11.
- This is very efficient tool.
- Highly configurable and reusable environment.
- Support and documentation could be improved.
- Some of the JDK versions are not supported.
- Microservices integration is needed.
- Making smaller docker images.
- Ability to use multiple languages like Python, NodeJS (TS), and java in polyglot environment.
- It seems to be unexpectedly faster than regular JVM.
- I would like to see more JavaFX support for cross platform UIs.
- I would like to see better Java 16 support.
- Hoping Java 17 support will come at the same time as the release.
- Ability to compile the applications ahead of its time.
- Need less resources.
- Maintenance is easy.
- Compiler is fast.
- Efficiency increases.
- Size of the applications is reduced.
- Installation is complex.
- Improper documentation.
- Support for less number of languages.
- This supports Java 11 which results in better performance.
- The memory utilization is fairly very low.
- Customer service is bit on the back side and improvement is needed.
- Manual efforts are needed to make certain libraries work.
- Micro services are not properly supported.
- Where Java is already used.
- Already known vulnerabilities of Java can be fixed.
- Where there's a scope for performance improvement.
- Easy to configure.
- Consumes few resources.
- Compatible with traditional JAVA development.
- GraalVM performs very well, especially EE edition
- The short startup times for native images push Java more towards "cloud native" experience
- Integrating different languages using GraalVM leverages their combined strengths in an innovative way
- It should be possible to use GraalVM EE to distribute native images of JavaFX applications for mobile platforms, especially for Apple platforms.
- Native Images are a game changer. However, compiling complex applications can be a pain. Better support for an improved transition process are a must.
- Cloud-native applications, microservices, etc.
- Possibly speeding up when used as a runtime for message brokers as Kafka, Pulsar, etc. (checking this at the moment...)
- Developing native applications can be painful; better dev experience is a must here
- The price model for EE isn't suitable for small companies
- Reduce memory consumption
- Improve performance
- Improve startuptime
- Really difficult to use with reflection
- Some library not compatible (AKKA)
- Lack of documentation
- [Building] AI related projects that using programming languages on JVM.
- Accelerate Scala-based projects with native image.
- The download speed for prebuilt binaries of GraalVM CE on Github is slow, and I hope more download mirrors for GraalVM could be provided, maybe directly from its home site www.graalvm.org is a good idea.
- Hope to add built-in support OpenCL within GraalVM for heterogeneous parallel computing.
- Hope to add support for running GraalVM on RISC-V.
- Helps Team work
- Increase Efficiency
- Increase Effectiveness
- It's is good and I don't currently see areas for improvement. Visuals are great too!
- Reduces the application startup time
- Allows usage of multiple languages, such as Java and Scala in the same codebase
- Improved performance in range of C++
- Notarization of Mac OS 10.15
- Better support and documentation for debugging and profiling
- RXVT emulator bug
- Still missing some languages (DEV)
- Looks like they still having something being developed
Be aware there are some points that can be improved like a couple of languages are not accepted so far.
Like used to, it's easy to use and you can find a lot of information regarding the tool so if you need to do something fast, it's a good choice.
Sadly I don't see too many users so far but I hope it'll keep increasing and in a short period we will have more information and ofc issues fixed. So far, everything I needed I could find easily.
- Best performance of applications
- High efficiency of applications
- Reduced hardware requirements
- Lesser consumption of resources
- Universal support to multiple programming languages
- Reduced size of applications
- Creation of virtual images for testing on Android and iOS mobile operating systems
- Creation of native images
- Excellent support
- Documentations are detailed enough to learn and use easily
- Easy to use
- Unavailability of installer makes installation a hassle
- Compiling natives for non-Java faces problem with dependencies
- Standardizing Java dev environment
- Making deployed applications more maintainable
- Reusable environments for developers
- Positive performance gain
- Quick deployment cycles
- Difficult to migrate legacy applications to use GraalVM
- Initial setup for Java binaries can be difficult
- Some configuration options can be obscure at times
- Polyglot vm
- Reduced memory footprint
- Fast startup times
- Not always optimal native code (JIT sometimes is faster)
- Microservices support
- Hard to profile
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.
- Reducing software cold start time
- AOT--Native compile, which removes the dependency on the JRE and JVM
- Reduces application size. Combining native-compile and EXE compression significantly reduces the size of our containers
- Native compiles. We have problems figuring out how to package jars with all dependencies for compilation. This might be our problem as we progress through the learning curve.
- More support and testing for Sprint and GraalVM.
- I recommend providing installer packages instead of downloading zip files.
- Reduced application size.
- Faster cold start, which improves HTTP request/response-based software.
- Native compiles dramatically simplifies building and deploying Java-based containers.
- Native compiles often significantly improves application performance.
- Well documented
- Easy to use
- Excellent for micro services
- Some limitations on technology, e.g. reflection, but can be mitigated.
- Supports multiple languages on a single virtual machine
- Eliminates any foreign language execution overhead
- Enterprise edition with professional support is available
- It is quite new product on the market and it feels not completely mature
- We were getting rather big memory footprints when using it with Kotlin
- Easy way of collaborating technologies
- Resolving the issues with native images
- Enhancing the limitation of applications across the platforms
- GraalVM creates the virtual images for testing on the platforms like iOS and Android
- It supports both open-source and enterprise editions
- Documentation of and help with few minor issues with GraalVM commands
- Demoing the use cases with GraalVM capabilities
- Showcase how it is used across the platforms
- Language Interoperability
- Ahead of Time compilation
- Great Support
- Requires a separate download to use
- Unavailable with the current JDK versions
- Requires users to specifically use GraalVM to use our server platform
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.
- Language Interop
- Open Source
- Ease of Use
- JDK version is low
- Lacks some features like ZGC
- JNI is sometimes faster
Other scenarios would be to take advantage of GraalVMs AOT features where performance is needed.
- Application runs faster
- Memory utilization is very low
- Not much improvement needed; the product suits our requirements.