What is WildFly?

Fast Startup

Experience ground breaking startup speed!

In the highly optimized boot process of WildFly 8, services are started concurrently to eliminate unnecessary waits and to tap into the power of multi-core processors. Non-critical services are kept on ice until first use.

As a result, WildFly offers a 10-fold reduction in startup time over previous versions and even gives Jetty and Tomcat a run for their money.

Ultimate Web Performance & Scalability

Connectivity, responsiveness, and the ability to scale are of the utmost importance for modern web applications. To meet these demands we have developed a new flexible high performance web server, called Undertow , and it's an integral part of WildFly 8. Undertow has the ability to scale to over a million connections, and third party benchmarks have shown it besting the competition when it comes to throughput.

Memory Diet

WildFly takes an aggressive approach to memory management. The base runtime services were developed to minimize heap allocation. These services use common cached indexed metadata over duplicate full parses, which reduces heap and object churn. The use of modular class loading prevents duplicate classes and loading more than the system configuration requires. This not only reduces the base memory overhead but also helps to minimize garbage collector pauses. Finally the administration console is 100% stateless and purely client driven. It starts instantly and requires zero memory on the server.

These optimizations combined enable WildFly to run with stock JVM settings and also on small devices. It also leaves more headroom for application data and supports higher scalability.

Slimable / Customizable Runtime

WildFly's architecture is based on pluggable subsystems that can be added or removed as needed. This allows you to remove capabilities you dont need, and also reduce the overall disk footprint and memory overhead required by the server.

This is all controlled by configuration which is arranged into subsystem blocks. To remove a subsystem you simply need to delete that simple block of configuration. For example, if you decide you only want Servlet support, you can delete every subsystem but the "undertow" subsystem.

Unified configuration & Management

Rather than sending you on a wild goose chase to change a setting in the application server, configuration in WildFly is centralized, simple and user-focused. The configuration file is organized by subsystems that you can easily comprehend and no internal server wiring is exposed. Subsystems use intelligent defaults, but can still be customized to best fit your needs. If you are running in domain mode, the configuration for all servers participating in the domain is specified in a well-organized manner within the same file.

Configuration changes aren't limited to file edits. All management capabilities are exposed in a unified manner across many forms of access. These include a CLI, a web based administration console, a native Java API, an HTTP/JSON based REST API, and a JMX gateway. These options allow for custom automation using the tools and languages that best fit your needs.

Domain & Standalone Management

WildFly offers two modes: a traditional, single JVM, standalone mode, and a multi-JVM option, domain mode, which synchronizes configuration across any number of processes and hosts.

All of the management capabilities previously described are available in both modes. However domain mode adds a central control point, the domain controller, for all of your systems.

Unlike solutions from other products, domain mode was designed to consume minimal resources, and in the case of failure to not impact running applications. Also, if you have a large domain, you can directly query each individual host for runtime metrics, which prevents the domain controller from becoming a bottleneck.

Java EE 8

WildFly implements the latest in enterprise Java standards. Java EE8 improves developer productity by providing rich enterprise capabilities in easy to consume frameworks that eliminate boiler plate and reduce technical burden. This allows your team to focus on the core business needs of your application.

In addition the frameworks that compose Java EE are heavily tested in combination. Using these standards means you no longer have to worry about finding the magic combination of various frameworks (and versions) that happen to work together.

Finally, building your application on standards allows you the flexibility to migrate between various vendor solutions. If you have applications using these standards on another, perhaps proprietary server, migrating to WildFly could breathe some fresh air into those applications.

Modern Web

WildFly supports the latest standards for web development. Web Socket support allows your applications the ability to use optimized custom protocols and full-duplex communication with your backend infrastructure. This is particular useful in communicating with mobile devices.

As web applications have evolved to become more client oriented with rich dynamic JavaScript, data access over the web has become critical. WildFly supports the latest standards for REST based data access, including JAX-RS 2, and JSON-P.

The connectivity and responsiveness needs of modern web applications are greater than ever. While WildFly will optimize traditional blocking I/O applications, it also provides asynchrous and non-blocking APIs that allow you to maximize the performance of critical resources in your application.

Lastly, fault tolerance, clustering, session replication, and efficient web proxying are all baked into WildFly as base level features.

No more jar hell!

Hierarchical classloaders are problematic, often causing failed deployments and quirky behavior. The time has come to say goodbye to the parent delegation model and find the path to modularity (i.e. sane classloading).

WildFly does classloading right. It uses JBoss Modules to provide true application isolation, hiding server implementation classes from the application and only linking with JARs your application needs. Modules, packaged as collections of classes, are peers that remain isolated unless explicitly defined as a dependency of another module. Visibility rules have sensible defaults, yet can be customized.

Fast Linking & Concurrent Loading

The dependency resolution algorithm in JBoss Modules is O(1), which means that classloading performance is not affected by the number of versions of libraries you have installed.

Classes are loaded concurrently, allowing for quick class discovery and loading, even on large deployments.

Arquillian

From the very start, WildFly has been designed with testability in mind. The secret to that fidelity is Arquillian , a component model for integration tests that execute inside the real runtime environment.

By removing the clutter from your tests and handling deployment and test execution, Arquillian enables you to write tests for just about any use case your application encounters: real tests.

Thanks to the speed of WildFly, Arquillian tests run nearly as fast as unit tests.

Smarter Development

The quick boot of WildFly combined with the easy-to-use Arquillian framework allows for test driven development using the real environment your code will be running in. You no longer need to pollute your application object model with mock classes and test code. Your test code is separate and simply deployed along side your application where it has full access to server resources.

WildFly builds on many best of breed standalone OSS projects, many of which you're likely to recognize:

• Hibernate
• Narayana
• Infinispan
• IronJacamar
• RESTEasy
• Weld

• HornetQ
• JGroups
• Mojarra
• Apache CXF
• Arquillian
• And more ...