How Storm
compares.

There is no universally best data framework. Storm is built for teams who want explicit, predictable database access with concise, immutable models. Here is where it sits next to the alternatives, and where each of them is the better call.

At a glance

Decision-relevant differences across the most common choices. This page compares the designs; the measured numbers, on identical workloads, live on the benchmarks page.

FeatureStormJPA / HibernatejOOQExposedKtorm
Entity modelImmutable data class (~5 lines)Mutable class (~30, ~10 with Lombok)Generated from schemaDSL table object (+ optional DAO)Mutable interface (+ DSL table)
Immutable entitiesYesNoYesDSL onlyNo
Type-safe queriesYesCriteria APIYesYesYes
N+1 handlingSingle-query entity graphCommon pitfallManualManual joins (DSL) · eager-load (DAO)Manual
Query across relationsOne line: joins and mapping derived from @FKJPQL strings or Criteria buildersImplicit path joins + multisetManual joins and row mappingManual joins
Session stateNone: no session, no flushPersistence context, flush, dirty checkingNoneDSL none · DAO transaction-boundPer-entity change tracking
Deferred loadingExplicit Ref<T>Proxies, session-boundNot applicableDAO lazy, transaction-boundManual joins
Standalone transactionsPropagation, isolation, timeout, commit hooksEntityTransaction · JTA/Spring for moreLambda API, nestedNested, isolation configLambda API
Row mappingCompile-time generated, reflection-freeReflection / bytecodeGenerated recordsManual (DSL)Dynamic proxies
GraalVM native imagesNative support for Spring and KtorVia Spring Boot AOT or QuarkusReflection config for generated recordsVia the Spring Boot integrationManual configuration
Full SQL escape hatchSQL / SQL templatesNative queriesIt is SQLRaw exec()Raw JDBC
LanguagesKotlin + JavaKotlin + JavaKotlin + JavaKotlin onlyKotlin only
LicenseApache 2.0LGPL 2.1Commercial for some DBsApache 2.0Apache 2.0

Framework by framework

A short, fair take on each. Every card links to the full pairing in the docs, with feature tables and code.

Storm vs JPA / Hibernate→
The default for Java persistence. Storm trades managed entities, proxies, and lazy loading for immutable records and explicit, single-query loading.
Java + KotlinMutable, managed
Storm vs Spring Data JPA→
Repositories over JPA, with queries derived from method names. Storm keeps the repository convenience but writes explicit query bodies over stateless entities.
Java + KotlinDerived queries
Storm vs jOOQ→
A type-safe SQL DSL generated from your schema. jOOQ excels at complex SQL; Storm is more concise for entity work, deriving joins from @FK. Storm is fully open source.
Java + KotlinSQL-shaped DSL
Storm vs Jimmer→
The closest peer: a modern, immutable, stateless Kotlin and Java ORM that also prevents N+1. The difference is conciseness. Storm keeps a plain data class and one-line queries; Jimmer uses interface entities, @IdView, and explicit fetchers for GraphQL-style shaping.
Java + KotlinImmutable
Storm vs MyBatis→
A SQL mapper: you write every statement, Storm infers the common ones from entities and lets you drop to SQL templates for the rest.
Java + KotlinHand-written SQL
Storm vs Exposed→
JetBrains’ Kotlin framework, defining tables as DSL objects. Storm declares the model once as annotated data classes and supports seven Spring-style transaction propagation modes without requiring Spring.
Kotlin onlyDSL tables
Storm vs Ktorm→
A lightweight Kotlin ORM built on mutable entity interfaces and DSL tables. Storm uses immutable data classes and loads relationships in a single query.
Kotlin onlyMutable interfaces
Try Storm → See the benchmarks Full comparison