Lightweight asynchronous framework for efficient and scalable web, network and big data solutions
DK: http - 186.1 Krps
Vert.x: http - 162.9 Krps
DK: HTTP
186.1 Krps
Vert.x: HTTP
162.9 Krps
DataKernel: di - 7.2 Mrps Guice: di - 1.3 Mrps Spring: di - 1.3 Krps
DK: DI
7.2 Mrps
Guice: DI
1.3 Mrps
Spring: DI
1.3 Krps
DataKernel: Memcache - 10.1 Mrps
DK : Memcache
9.8 Mrps
DataKernel: RPC - 15.6 Mrps
DK : RPC
15.6 Mrps
DataKernel: Promise - 77.2 Mrps
JDK: Futures - 11.7 Mrps
DK: Promise
77.2 Mrps
JDK: Futures
11.7 Mrps

Alternative to conventional frameworks

DataKernel is a full-featured alternative web and big data Java framework built from the ground up. It does not use Netty, Jetty, Spring/Guice DI, RxJava etc. Instead, it features a full application stack: Event Loop, Promises, HTTP, DI and others, including decentralized big-data technologies and map-reduce algorithms.

No overhead of intermediate abstractions, legacy standards and third-party libraries makes the framework minimalistic, streamlined and lightning-fast!

DataKernel structure

The raw speed isn't the main DataKernel advantage. Its main goal is to give a simple but comprehensive all-in-one solution which allows to consistently create applications of any complexity, from simple web apps to high-performance scalable backend microservices solutions. DataKernel incorporates a stack of loosely coupled components which perfectly complement and empower each other. It’s much more than the sum of the parts.

Why choose DataKernel:

All-in-one holistic solution

With DataKernel you don't need to deal with a zoo of technologies to create applications of any complexity. Moreover, you can consistently implement prototyping and scaling within one framework.

No intermediate abstractions and adapters

Since DataKernel was built from the ground up, there are no layers of abstractions and adapters over legacy standards and third-party libraries which makes DataKernel concise and streamlined.

Impeccable performance

No third-party dependencies in addition to thoroughly optimized core components make DataKernel faster than any similar solution.

High-level programming approach

DataKernel has a simple yet powerful set of abstractions with clean OOP design favoring Java 8+ functional programming style.

Excels in high-load scenarios

Low latency and high throughput speed allow to develop high-load applications with a competitive edge.

Cost-effective

DataKernel principles are easy to grasp, fast to learn and allow to develop apps faster. Moreover, DataKernel solutions require less servers.

Conferences

xp-days-logo
We're speaking at the XP Days conference on 21 November. We'll tell the story and behind-the-scenes secrets of DataKernel creation - the new framework which redefines Java development approaches and revolutionizes the industry!
cube

Comparison to other popular frameworks

DataKernel
Spring
Node.js
Ruby on Rails
Django
Suitable for enterprise-level solutions
plus
plus
plus
plus
plus
Low entry barrier level
plus
plus
plus
plus
Designed asynchronous
plus
plus
plus
Explicit specifications instead of implicit conventions
plus
plus
plus
Legacy-free, no third-party dependencies
plus
plus
plus
plus
IDE friendly, statically-typed high-performance language
plus
plus
Lightweight asynchronous framework for efficient and scalable web, network and big data solutions
GET STARTED

Create your applications simpler than ever before

A set of predefined launchers and classes for typical use cases allows you to develop apps extremely fast. Create an async HTTP server in less than 15 lines of code with no additional configuration files.
public final class HttpHelloWorldExample extends HttpServerLauncher {
	@Provides
	AsyncServlet servlet() {
		return request -> Promise.of(ok200().withPlainText("Hello World"));
	}

	public static void main(String[] args) throws Exception {
		Launcher launcher = new HttpHelloWorldExample();
		launcher.launch(args);
	}
}

Dependency Injection: Redefined

DataKernel DI is lightning-fast: four times faster than Guice and up to 100s of times faster than Spring. This result is achieved because of dependency graph being compiled at start-up time into efficient runtime internal representation. Thus, there are no overheads during runtime.

Besides being extremely fast, DataKernel DI is even more powerful: it supports nested scopes, singletons, multithreaded and single-threaded modes, object factories, modules and plugins for transforming dependencies graph at startup time, abstracting out all reflection. These plugins extensively use Java 8+ functional-style programming for binding definitions, generators and user-defined binding transformations.

public final class HelloWorldExample extends Launcher {

	@Inject
	String message;

	@Provides
	String message() {
		return "Hello, world!";
	}

	@Override
	protected void run() {
		System.out.println(message);
	}

	public static void main(String[] args) throws Exception {
		Launcher launcher = new HelloWorldExample();
		launcher.launch(args);

	}
}

Get Started

DataKernel is a production-ready framework which constantly evolves and gets new updates. The essential DataKernel modules form the basis of diverse high-load applications processing billions of requests daily: in-house ad-serving solutions, online analytics and web crawlers.

Try DataKernel right now by completing the Getting-Started tutorial. You can also explore docs to find out more about DataKernel modules. It is also worth to note that due to the usage of Node.js-inspired features, DataKernel is a perfect framework to get started with Java if you are a JavaScript developer.