# Kora Framework

> Kora is a backend framework for Java and Kotlin that builds the application graph and dependency injection at compile time, generates transparent source code with no runtime reflection, runs application code on virtual threads, and ships production-ready modules for HTTP, databases, Kafka, gRPC, OpenTelemetry and testing. Apache 2.0 licensed, source: https://github.com/kora-projects/kora

Russian version: https://kora-projects.github.io/kora-docs/v2/ru/llms.txt

## Documentation

- [Introduction](https://kora-projects.github.io/kora-docs/v2/en/guides/home/): Explains where to start with Kora guides and examples, how to choose between step-by-step guides and complete repository examples, and where to find working Java and Kotlin applications for HTTP, OpenAPI, JDBC, Cassandra, Kafka, gRPC, S3, cache, resilience, validation, observability and testing. Use when planning a learning path through the Kora documentation. Topics: Kora Framework, Kora guides, Kora examples, Java tutorial, Kotlin tutorial, backend framework tutorial.
- [Creating Your First Kora Application](https://kora-projects.github.io/kora-docs/v2/en/guides/getting-started/): Step-by-step first Kora application: Gradle wrapper and JDK toolchain setup, the io.koraframework:kora-bom BOM, annotation-processors and symbol-processors, a @KoraApp graph root with HoconConfigModule, JsonModule, LogbackModule and UndertowPublicHttpServerModule, one @HttpController route, httpServer configuration and the generated graph and handler sources. Topics: Kora Framework, Kora getting started, Kora hello world, Java REST service, Kotlin backend, Gradle, @KoraApp.
- [Dependency Injection with Kora](https://kora-projects.github.io/kora-docs/v2/en/guides/dependency-injection-introduction/): Conceptual introduction to Kora 2.0 compile-time dependency injection: how @KoraApp generates the application graph started through KoraApplication and ApplicationGraphDraw, the io.koraframework.common.annotation set (@Component, @Module, @KoraSubmodule, @Root, @DefaultComponent, @Tag, @Conditional, @FactoryModule), component discovery order and the dependency resolution algorithm, the claim kinds required, @Nullable, ValueOf, PromiseOf, All and TypeRef from io.koraframework.application.graph, tag matching with Tag.Any, Lifecycle init and release, and the graph build errors the compiler reports. Topics: Kora Framework, Kora introduction, dependency injection tutorial, compile-time DI, @Component, @Module, Kora tags.
- [Building Kora DI Applications](https://kora-projects.github.io/kora-docs/v2/en/guides/dependency-injection/): Step-by-step multi-module Kora 2.0 application built around the dependency graph: a @KoraApp root, io.koraframework.common.annotation annotations (@Component, @Module, @KoraSubmodule, @DefaultComponent, @Tag, @Root, @FactoryModule), All<T> and ValueOf<T> claims, JSpecify @Nullable optional dependencies, Lifecycle and LifecycleWrapper, generic factories, and the Gradle setup with io.koraframework:kora-bom, annotation-processors and symbol-processors. Topics: Kora Framework, Kora dependency injection, DI guide, compile-time DI, Kora modules, Kora tags, Java DI.
- [Configuration Management with Kora](https://kora-projects.github.io/kora-docs/v2/en/guides/config-hocon/): Step-by-step type-safe HOCON configuration for a Kora 2.0 service: the io.koraframework:config-hocon artifact, HoconConfigModule, @ConfigSource for an application section, @ConfigMapper plus ConfigValueMapper.mapOrThrow for a reusable library shape, @Tag to bind one config type to several paths, required ${VAR} and optional ${?VAR} substitutions, HOCON object reuse and include, config.resource and config.file selection, and the generated config mapper and module sources. Topics: Kora Framework, Kora HOCON, HOCON configuration, type-safe config, @ConfigSource, Java configuration, Kotlin configuration.
- [YAML Configuration Management with Kora](https://kora-projects.github.io/kora-docs/v2/en/guides/config-yaml/): Step-by-step type-safe YAML configuration for a Kora 2.0 service: the io.koraframework:config-yaml artifact, YamlConfigModule, @ConfigSource for an application section, @ConfigMapper plus ConfigValueMapper.mapOrThrow for a reusable library shape, @Tag to bind one config type to several paths, the Kora ${path}, ${?path} and ${path:default} substitution forms, application.yaml and reference.yaml resolution, config.resource and config.file selection, and the generated config mapper and module sources. Topics: Kora Framework, Kora YAML, YAML configuration, type-safe config, @ConfigSource, Java configuration, Kotlin configuration.
- [JSON Processing with Kora](https://kora-projects.github.io/kora-docs/v2/en/guides/json/): Step-by-step JSON request and response mapping for a Kora 2.0 HTTP API: the io.koraframework:json-common artifact, JsonModule, @Json on DTOs and on controller parameters and return values, compile-time generated JsonReader and JsonWriter classes, sealed polymorphic responses with @JsonDiscriminatorField and @JsonDiscriminatorValue, the nullable JsonReader.read contract, JsonWriter.toByteArray and toString, and reading the generated JSON sources. Topics: Kora Framework, Kora JSON, JSON serialization, JsonReader, JsonWriter, REST API JSON, no reflection.
- [HTTP Server Guide](https://kora-projects.github.io/kora-docs/v2/en/guides/http-server/): Step-by-step Kora HTTP API: the io.koraframework:http-server-undertow module, UndertowPublicHttpServerModule, @HttpController and @HttpRoute routes, @Json request and response bodies, @Path and @Query binding, HttpResponseEntity and HttpServerResponse, HttpServerResponseException errors, a controller-service-repository split and the httpServer.port / httpServer.system.port configuration. Topics: Kora Framework, Kora HTTP server, REST API Java, REST API Kotlin, @HttpController, Undertow, CRUD API.
- [HTTP Server Advanced Guide](https://kora-projects.github.io/kora-docs/v2/en/guides/http-server-advanced/): Advanced Kora HTTP server topics: HttpServerRequestMapper with @Mapping for typed request context, FormUrlEncoded and FormMultipart bodies, controller interceptors with @InterceptWith, global interceptors tagged @Tag(HttpServer.class), a shared JSON error contract built on JsonWriter.toByteArray, API-key authorization from @ConfigSource, the generated controller module, imperative HttpServerRequestHandlerImpl routes and parallel work inside a synchronous handler. Topics: Kora Framework, Kora HTTP interceptors, HTTP server advanced, multipart upload, API key authorization, error handling, Undertow.
- [HTTP Client with Kora](https://kora-projects.github.io/kora-docs/v2/en/guides/http-client/): Step-by-step declarative HTTP client for a Kora 2.0 service: the io.koraframework:http-client-ok artifact and OkHttpClientModule, a @HttpClient interface whose @HttpRoute methods bind @Path, @Query, @Header and @Cookie parameters and @Json request and response DTOs, HttpResponseEntity returns and a custom HttpClientResponseMapper, HttpClientResponseException on non-2xx answers, the httpClient.userApi url, requestTimeout and telemetry configuration next to httpServer.port and httpServer.system.port, and a @KoraAppTest check of the client against the running server application. Topics: Kora Framework, Kora HTTP client, declarative HTTP client, @HttpClient, REST client Java, REST client Kotlin, Feign alternative.
- [HTTP Client Advanced Guide](https://kora-projects.github.io/kora-docs/v2/en/guides/http-client-advanced/): Advanced declarative HTTP client patterns for Kora 2.0: FormUrlEncoded and FormMultipart request bodies built from FormPart values, a custom HttpClientRequestMapper attached with @Mapping, @ResponseCodeMapper with ResponseCodeMapper.DEFAULT and per-status HttpClientResponseMapper implementations, HttpClientInterceptor applied through @InterceptWith for method logging and API-key authorization backed by @ConfigSource and @ConfigMapper, per-operation settings from HttpClientOperationConfig, and the imperative HttpClient with HttpClientRequest.of and a closeable HttpClientResponse. Topics: Kora Framework, Kora HTTP client advanced, response code mapping, client interceptors, API key authorization, REST client.
- [Contract-First HTTP Server with OpenAPI](https://kora-projects.github.io/kora-docs/v2/en/guides/openapi-http-server/): Contract-first Kora HTTP server from an OpenAPI file: the org.openapi.generator Gradle plugin with generatorName kora, configOptions mode java-server / kotlin-server, enableServerValidation, the generated UsersApiController, UsersApiDelegate and sealed UsersApiResponses wrappers, generated TO models, and openapi.management.files with /openapi, /swagger-ui and /scalar. Topics: Kora Framework, Kora OpenAPI, OpenAPI server generation, contract-first API, openapi-generator, REST API, API validation.
- [Contract-First HTTP Server Advanced Guide](https://kora-projects.github.io/kora-docs/v2/en/guides/openapi-http-server-advanced/): Advanced contract-first Kora HTTP server: a second OpenAPI contract and a second GenerateTask, generated form and multipart FormParam records, sealed response wrappers, controller interceptors declared through the extensions generator option, a custom ViolationExceptionHttpServerResponseMapper, JsonNullable model fields, and API-key authorization through ApiSecurity markers and HttpServerPrincipalExtractor. Topics: Kora Framework, Kora OpenAPI advanced, OpenAPI multiple contracts, OpenAPI authorization, openapi-generator, multipart.
- [Contract-First HTTP Client with OpenAPI](https://kora-projects.github.io/kora-docs/v2/en/guides/openapi-http-client/): Contract-first Kora HTTP client from an OpenAPI file: the org.openapi.generator Gradle plugin with generatorName kora, configOptions mode java-client / kotlin-client, clientConfig and clientConfigPrefix, the generated @HttpClient interface with @ResponseCodeMapper, sealed <Api>Responses wrappers, clientResponseMode SUCCESSFUL with typed error exceptions, OptArgs holders for optional parameters, enum fromValue, and testing the generated client against a Testcontainers copy of the server. Topics: Kora Framework, Kora OpenAPI client, OpenAPI client generation, openapi-generator, typed HTTP client, contract-first.
- [Database Integration with Kora](https://kora-projects.github.io/kora-docs/v2/en/guides/database-jdbc/): Step-by-step PostgreSQL persistence with Kora JDBC: the io.koraframework:database-jdbc and database-flyway artifacts, JdbcDatabaseModule and FlywayJdbcDatabaseModule, an @EntityJdbc DAO with @Column mapping, a @Repository extending JdbcRepository with @Query, Optional and UpdateCount results, the jdbc configuration section with Hikari pool settings, flyway.locations and the generated repository and row mapper sources. Topics: Kora Framework, Kora JDBC, Kora repository, PostgreSQL Java, SQL repository, Hikari, ORM alternative.
- [Advanced JDBC with Kora](https://kora-projects.github.io/kora-docs/v2/en/guides/database-jdbc-advanced/): Advanced Kora JDBC repository patterns on PostgreSQL: a second table with a nullable foreign key, @EntityJdbc insert models, the %{entity#inserts} macro, @Batch inserts with @Id generated keys, custom JdbcParameterColumnMapper and JdbcResultColumnMapper components, PostgreSQL array parameters with ANY(:ids), nested @Embedded projections and transactions through JdbcRepository.executor().inTx(...). Topics: Kora Framework, Kora JDBC advanced, SQL macros, JDBC transactions, PostgreSQL mapper, Flyway, projections.
- [Cassandra Database Integration with Kora](https://kora-projects.github.io/kora-docs/v2/en/guides/database-cassandra/): Step-by-step Cassandra-compatible persistence for a Kora 2.0 service: the io.koraframework:database-cassandra artifact and CassandraDatabaseModule, a @Repository interface extending CassandraRepository with explicit CQL @Query methods, an @EntityCassandra DAO record mapped with @Table and @Column, service-level existence checks that keep 404 behavior because Cassandra mutations carry no affected-row count, the cassandra.auth and cassandra.basic configuration section with contactPoints, dc, sessionKeyspace and request.timeout, and Scylla Testcontainers verification of the generated repository implementation. Topics: Kora Framework, Kora Cassandra, Apache Cassandra Java, CQL repository, Cassandra driver, NoSQL.
- [Caching Strategies with Kora](https://kora-projects.github.io/kora-docs/v2/en/guides/cache/): Step-by-step in-process caching for a Kora 2.0 service with Caffeine: the io.koraframework:cache-caffeine artifact, CaffeineCacheModule, a typed @Cache contract extending CaffeineCache<K, V>, the @Cacheable, @CachePut, @CacheInvalidate and @CacheInvalidateAll aspects, the args attribute that selects cache key parameters, imperative warm-up through the injected cache contract, the cache.caffeine configuration section, and the generated AOP proxy and cache implementation sources. Topics: Kora Framework, Kora cache, @Cacheable, Caffeine cache, cache invalidation, compile-time AOP, Java caching.
- [Multi-Level Caching with Redis](https://kora-projects.github.io/kora-docs/v2/en/guides/cache-multi-level/): Step-by-step two-level caching for a Kora 2.0 service: keeping the Caffeine L1 cache from the cache guide and adding a shared Redis L2 cache through the io.koraframework:cache-redis-lettuce artifact and LettuceRedisCacheModule, a second @Cache contract extending RedisCache<String, @Json UserResponse>, stacked @Cacheable, @CachePut with the args attribute and @CacheInvalidate annotations applied in declaration order, imperative warm-up of both levels, and the cache.caffeine, cache.redis and lettuce configuration sections. Topics: Kora Framework, Kora multi-level cache, Redis cache, Caffeine, two-level cache, distributed cache.
- [Build Resilient CRUD Operations with Retry, Timeout, Circuit Breaker, and Fallback](https://kora-projects.github.io/kora-docs/v2/en/guides/resilient/): Step-by-step resilience for a Kora 2.0 service: the io.koraframework:resilient-kora artifact and ResilientModule, typed spec interfaces declared with @RetrySpec, @TimeoutSpec, @CircuitBreakerSpec and @RateLimiterSpec (or @RateLimiterDistributedSpec for a Redis-backed limit), the @Retryable, @Timeout, @CircuitBreakable, @RateLimited and @Fallback aspects that reference them by class, the resilient configuration section with countBased.windowSize and the circuit breaker type, the rate limiter type (TOKEN_BUCKET by default or FIXED_WINDOW), a CircuitBreakerPredicate bound with @Tag, the NonRetryableException and NonCircuitableException markers, @Fallback.Reason, and the generated AOP proxy sources. Topics: Kora Framework, Kora resilience, circuit breaker, retry, rate limiter, fault tolerance, Resilience4j alternative.
- [Validation with Kora](https://kora-projects.github.io/kora-docs/v2/en/guides/validation/): Step-by-step request validation for a Kora 2.0 HTTP API: the io.koraframework:validation-module artifact and ValidationModule, Kora's own constraint annotations in io.koraframework.validation.common.annotation, @Valid on a record and on a parameter, @Validate for method argument and result validation, the generated $UserRequest_Validator and $UserController__AopProxy sources, ViolationException and Violation.path().full(), and a global ViolationExceptionHttpServerResponseMapper plus ValidationHttpServerInterceptor tagged with @Tag(HttpServer.class). Topics: Kora Framework, Kora validation, bean validation alternative, input validation, @Valid, HTTP 400.
- [Observability & Monitoring with Kora](https://kora-projects.github.io/kora-docs/v2/en/guides/observability/): The Kora observability hub: how metrics, tracing, logging and probes fit together in one application, which telemetry is on by default and which is not, the complete module graph with MetricsModule and OpentelemetryHttpExporterModule, the full httpServer.system, tracing and logging configuration, traceId correlation in log lines, the system port that serves /metrics and the probes, and links to the focused metrics, tracing and probes guides. Topics: Kora Framework, Kora observability, OpenTelemetry, Prometheus, distributed tracing, structured logging, health probes.
- [Metrics with Kora](https://kora-projects.github.io/kora-docs/v2/en/guides/observability-metrics/): Step-by-step Micrometer metrics for a Kora HTTP service: the io.koraframework:micrometer-module dependency, MetricsModule and the injected MeterRegistry, the Prometheus scrape endpoint on httpServer.system.metricsPath, the telemetry.metrics.enabled flag that gates every component metric, slo histogram buckets and common tags, the application-wide metrics.enabled switch and metrics.tags common tags, and a custom MetricsService with a Timer, a tagged Counter and a ConcurrentHashMap meter cache. Topics: Kora Framework, Kora metrics, Micrometer, Prometheus, MeterRegistry, business metrics.
- [Tracing with Kora](https://kora-projects.github.io/kora-docs/v2/en/guides/observability-tracing/): Step-by-step OpenTelemetry tracing for a Kora HTTP service: the io.koraframework:opentelemetry-tracing-exporter-http dependency, OpentelemetryHttpExporterModule, the tracing and tracing.exporter configuration sections, service.name resource attributes and OpentelemetryTracingAttributesProvider, business spans created with KoraTracer traceParent and traceNew, span attributes and error recording, ScopedValue-based trace context, traceId and spanId log correlation, and verifying a trace in Jaeger. Topics: Kora Framework, Kora tracing, OpenTelemetry, OTLP, distributed tracing, spans, log correlation.
- [Probes with Kora](https://kora-projects.github.io/kora-docs/v2/en/guides/observability-probes/): Step-by-step liveness and readiness probes for a Kora HTTP service: the LivenessProbe and ReadinessProbe interfaces from io.koraframework:common, probe endpoints on the system HTTP server, the httpServer.system.port, livenessPath and readinessPath configuration, custom probe components registered as a plain @Component, warm-up readiness, built-in framework probes, aggregation across several probes, the 200/503/408 response contract, and Kubernetes probe wiring. Topics: Kora Framework, Kora probes, liveness probe, readiness probe, Kubernetes health check, health endpoint.
- [Messaging with Kafka](https://kora-projects.github.io/kora-docs/v2/en/guides/messaging-kafka/): Step-by-step event-driven messaging for a Kora 2.0 service with Apache Kafka: the io.koraframework:kafka artifact and KafkaModule, a generated @KafkaPublisher interface with @KafkaPublisher.Topic pointing at a named topic config section, a @KafkaListener consumer with the defensive event-plus-exception signature, @Json event payloads, the kafka.producer and kafka.consumer configuration sections with driverProperties, and a local Kafka broker through Docker Compose. Topics: Kora Framework, Kora Kafka, Apache Kafka Java, Kafka consumer, Kafka producer, event-driven microservices.
- [gRPC Server with Kora](https://kora-projects.github.io/kora-docs/v2/en/guides/grpc-server/): Step-by-step unary gRPC server on Kora 2.0: the io.koraframework:grpc-server artifact and GrpcServerModule, the com.google.protobuf Gradle plugin with protoc 4.36.2 and the io.grpc runtime pinned to 1.84.0, a user_service.proto contract using google.protobuf.Empty and Timestamp, a @Component handler extending the generated UserServiceGrpc.UserServiceImplBase that answers through StreamObserver, Status.NOT_FOUND and Status.INTERNAL error mapping, and the grpcServer.port and grpcServer.telemetry.logging.enabled configuration. Topics: Kora Framework, Kora gRPC server, gRPC Java, gRPC Kotlin, protobuf, grpc-java.
- [Advanced gRPC Server with Kora](https://kora-projects.github.io/kora-docs/v2/en/guides/grpc-server-advanced/): Advanced Kora gRPC server: a second protobuf service with server, client and bidirectional streaming handlers, global ServerInterceptor components scoped in code by SERVICE_NAME, API-key authorization read from gRPC Metadata through a @ConfigSource, gRPC reflection via io.grpc:grpc-services and grpcServer.reflectionEnabled, and @KoraAppTest streaming tests. Topics: Kora Framework, Kora gRPC streaming, gRPC interceptors, gRPC reflection, gRPC authorization, grpc-java.
- [gRPC Client with Kora](https://kora-projects.github.io/kora-docs/v2/en/guides/grpc-client/): Step-by-step Kora gRPC client: the io.koraframework:grpc-client module and GrpcClientModule, the protobuf Gradle plugin, generated UserServiceGrpc stubs injected without a @Tag, the grpcClient.<Service> configuration path derived from the protobuf service name, the url scheme choosing plaintext or TLS, timeout applied as a call deadline, wrapping a BlockingStub in an application service, and in-process client tests. Topics: Kora Framework, Kora gRPC client, gRPC stubs, protobuf, gRPC Java client, grpc-java.
- [Advanced gRPC Client with Kora](https://kora-projects.github.io/kora-docs/v2/en/guides/grpc-client-advanced/): Streaming Kora gRPC client: server, client and bidirectional streaming through the generated blocking and async stubs, StreamObserver lifecycles and completion signals, ClientInterceptor components scoped with @Tag(ServiceGrpc.class) for logging and metadata authorization, an API key read through @ConfigSource, the grpcClient.<Service> configuration section, and in-process streaming tests. Topics: Kora Framework, Kora gRPC client advanced, gRPC client interceptor, gRPC streaming client, gRPC authorization.
- [File Upload & Storage with S3](https://kora-projects.github.io/kora-docs/v2/en/guides/s3/): Step-by-step S3-backed file storage for a Kora 2.0 HTTP service using both S3 artifacts together: the declarative io.koraframework.experimental:s3-client-kora client with @S3.Client, @S3.Bucket, @S3.Put, @S3.Get, @S3.List and @S3.Delete, and the io.koraframework:s3-client-aws wrapper that publishes the AWS SDK S3Client for bucket administration. Covers the separate s3client.aws and s3client.uploads configuration sections, GetObjectResult and ListBucketResult, S3ClientNoSuchKeyException, a @Root Lifecycle bucket initializer, FormMultipart upload handling and MinIO for local runs and Testcontainers. Topics: Kora Framework, Kora S3, S3 client Java, object storage, MinIO, AWS S3.
- [JUnit Testing with Kora](https://kora-projects.github.io/kora-docs/v2/en/guides/testing-junit/): Component testing for Kora 2.0 with JUnit 5: the io.koraframework:test-junit5 artifact, @KoraAppTest and @TestComponent from io.koraframework.test.extension.junit5, Mockito @Mock and MockK @MockK inside the application graph, KoraAppTestConfigModifier with KoraConfigModification, test graph lifecycle and the Gradle test setup with JUnit 6.1.3 and byte-buddy alignment. Topics: Kora Framework, Kora testing, JUnit 5, @KoraAppTest, Mockito, MockK, component tests.
- [Integration Testing with Kora](https://kora-projects.github.io/kora-docs/v2/en/guides/testing-integration/): Integration testing for Kora 2.0 JDBC applications: a test-scope @KoraApp that extends the production application, io.koraframework:test-junit5 with @KoraAppTest and @TestComponent, Testcontainers 2.0 PostgreSQLContainer, KoraAppTestConfigModifier feeding the jdbc and flyway configuration sections through withSystemProperty, Flyway dialect artifacts and the kora.app.submodule.enabled processor option. Topics: Kora Framework, Kora integration testing, Testcontainers, PostgreSQL, JUnit 5, database testing.
- [Black Box Testing with Kora](https://kora-projects.github.io/kora-docs/v2/en/guides/testing-black-box/): Black box testing for a packaged Kora 2.0 application: building the distribution tar and a Dockerfile image, a Testcontainers 2.0 GenericContainer wrapper exposing httpServer.port 8080 and httpServer.system.port 8085, waiting on GET /system/readiness for status 200, passing configuration through container environment variables, and asserting HTTP status codes and JSON bodies from the outside. Topics: Kora Framework, Kora black-box testing, Testcontainers, Docker, end-to-end testing, API testing.
- [Project and build](https://kora-projects.github.io/kora-docs/v2/en/documentation/general/): Explains Kora framework fundamentals, annotation processors, KSP, JDK and Kotlin compatibility, Gradle build setup, dependencies, application entry point, and terminology. Use when working with @KoraApp, KoraApplication, annotation processors, KSP, Gradle, the io.koraframework:kora-bom BOM, application plugin. Topics: Kora Framework, Kora setup, Kora Gradle, kora-bom, annotation processors, KSP, JDK 25.
- [Dependency injection](https://kora-projects.github.io/kora-docs/v2/en/documentation/container/): Explains Kora compile-time dependency injection container, components, modules, factory modules, tags, conditions, lifecycle, graph resolution, and dependency wrappers. Use when working with @KoraApp, @Component, @Module, @KoraSubmodule, @FactoryModule, @Root, @Tag, @DefaultComponent, @Conditional, ValueOf. Topics: Kora Framework, Kora dependency injection, DI container, compile-time DI, @Component, @Module, @KoraSubmodule.
- [Configuration](https://kora-projects.github.io/kora-docs/v2/en/documentation/config/): Explains the Kora configuration system for HOCON and YAML, typed configuration mapping, configuration injection, config sources, the config watcher, and supported value types. Use when working with @ConfigSource, @ConfigMapper, ConfigValueMapper, @EnvironmentConfig, @SystemPropertiesConfig, @ApplicationConfig, Config, HoconConfigModule, YamlConfigModule. Topics: Kora Framework, Kora configuration, HOCON, YAML, @ConfigSource, typed configuration, config reload.
- [Json](https://kora-projects.github.io/kora-docs/v2/en/documentation/json/): Explains Kora compile-time JSON reader and writer generation, field requirements, naming strategies, ignores, serialization levels, value types, JsonNullable, sealed hierarchies, enums, custom codecs, parse errors, and the Jackson escape hatch. Use when working with @Json, @JsonReader, @JsonWriter, @JsonInclude, @JsonField, @JsonSkip, @JsonDiscriminatorField, @NamingStrategy, @Mapping, JsonNullable, RawJson, JacksonModule. Topics: Kora Framework, Kora JSON, JSON serialization Java, JsonNullable, Jackson alternative, no reflection.
- [MapStruct](https://kora-projects.github.io/kora-docs/v2/en/documentation/mapstruct/): Explains how Kora turns compile-time generated mappers into graph components: MapStruct @Mapper implementations in Java (annotation-processors, helper injection through uses and injectionStrategy, tags) and Konvert @Konverter implementations in Kotlin (symbol-processors, KSP, generated object Impl, tags, limitations). Use when working with @Mapper, @Mapping, MapStruct, mapstruct-processor, @Konverter, Konvert, konvert-api, generated Impl, uses, injectionStrategy, componentModel, @Tag, KSP. Topics: Kora Framework, Kora MapStruct, Kora Konvert, MapStruct, Konvert, object mapping, Java mappers, Kotlin mappers.
- [Probes](https://kora-projects.github.io/kora-docs/v2/en/documentation/probes/): Explains Kora readiness and liveness probes on the system HTTP server, probe paths in the httpServer.system config section, built-in framework probes, aggregation and response semantics, and Kubernetes-style availability reporting. Use when working with ReadinessProbe, LivenessProbe, ReadinessProbeFailure, LivenessProbeFailure, /system/readiness, /system/liveness. Topics: Kora Framework, Kora probes, liveness probe, readiness probe, Kubernetes, health check.
- [Logging](https://kora-projects.github.io/kora-docs/v2/en/documentation/logging-slf4j/): Explains Kora SLF4J logging: obtaining a Logger, the logging.levels configuration and its runtime refresh, per-component telemetry logging, the Logback module with KoraLogbackConfigurator, encoder selection (text, pretty, json), the logging-logback-json JsonRecordEncoder with field masking, KoraAsyncAppender and its bootstrap properties, structured logs and the scoped MDC. Use when working with LoggingModule, LogbackModule, LoggingConfig, LoggingLevelApplier, LogbackEncoderFactory, kora.logging.encoder, JsonRecordEncoder, StructuredArgument, MDC, KoraMdcConverter, telemetry.logging.enabled. Topics: Kora Framework, Kora logging, SLF4J, Logback, JSON logging, structured logging, MDC.
- [Metrics](https://kora-projects.github.io/kora-docs/v2/en/documentation/metrics/): Explains Kora metrics with Micrometer, Prometheus export through the system HTTP server, the application-wide metrics section (enabled switch and common tags), MetricsTagsProvider, per-module telemetry.metrics configuration, registry and metric factory customization, and a full metric reference. Use when working with MetricsModule, MetricsConfig, MetricsTagsProvider, MeterRegistry, MetricsScraper, PrometheusMeterRegistryInitializer, metrics.enabled, metrics.tags, telemetry.metrics.enabled, httpServer.system.metricsPath, Metrics Reference. Topics: Kora Framework, Kora metrics, Micrometer, Prometheus, telemetry, JVM metrics, MetricsConfig, MetricsTagsProvider, common tags.
- [Tracing](https://kora-projects.github.io/kora-docs/v2/en/documentation/tracing/): Explains Kora OpenTelemetry tracing with the OTLP/gRPC and OTLP/HTTP exporters, tracing configuration, Resource attributes from configuration and OpentelemetryTracingAttributesProvider components, trace context propagation, sampling, manual spans and carrying the trace context across threads. Use when working with OpentelemetryTracingModule, OpentelemetryTracingAttributesProvider, OpentelemetryGrpcExporterModule, OpentelemetryHttpExporterModule, KoraTracer, OpentelemetryContext, Tracer, Span, OTLP. Topics: Kora Framework, Kora tracing, OpenTelemetry, OTLP exporter, context propagation, sampling, Resource attributes, OpentelemetryTracingAttributesProvider.
- [HTTP server](https://kora-projects.github.io/kora-docs/v2/en/documentation/http-server/): Explains Kora HTTP server, declarative and imperative controllers, routing, request and response mapping, interceptors, error handling, authorization, telemetry masking and Undertow configuration. Use when working with @HttpController, @HttpRoute, @Path, @Query, @Header, @Cookie, @Json, @InterceptWith, MaskingStrategy, DataMasker. Topics: Kora Framework, Kora HTTP server, @HttpController, REST controller, Undertow, HTTP interceptors, HTTP telemetry masking.
- [HTTP client](https://kora-projects.github.io/kora-docs/v2/en/documentation/http-client/): Explains Kora HTTP clients, the OkHttp, Apache HttpClient and JDK transports, declarative client annotations, request and response mapping, interceptors, authorization, error mapping and telemetry with masking. Use when working with @HttpClient, @HttpRoute, @Path, @Query, @Header, @Cookie, @Json, @Mapping, @ResponseCodeMapper, @InterceptWith, HttpClientConnectionException, MaskingStrategy, DataMasker. Topics: Kora Framework, Kora HTTP client, @HttpClient, OkHttp, Apache HttpClient, declarative REST client, HTTP client telemetry masking.
- [SOAP client](https://kora-projects.github.io/kora-docs/v2/en/documentation/soap-client/): Explains Kora SOAP client setup, configuration, usage, generated clients, envelope processors and WS-Security, multipart/MTOM and RPC-style operations, logging, exception handling, testing, and the wsdl2java Gradle plugin. Use when working with SoapClientModule, wsdl2java, jakarta.jws.WebService, SOAPAction, SoapFaultException, SoapEnvelopeProcessorsUtils. Topics: Kora Framework, Kora SOAP client, SOAP Java, WSDL, wsdl2java, WS-Security.
- [OpenAPI codegen](https://kora-projects.github.io/kora-docs/v2/en/documentation/openapi-codegen/): Explains Kora OpenAPI code generation for HTTP clients and servers, generator modes, configuration options, generator extensions, validation, authorization and JsonNullable models. Use when working with openapi-generator, mode, clientConfig, clientConfigPrefix, clientResponseMode, SEALED, SUCCESSFUL, HttpClientResponseException, SuccessfulResponseMapper, typeMappings, securityConfigPrefix, extensions, rawBodyMode, delegateMethodBodyMode, prefixPath, requestInDelegateParams, ApiSecurity, HttpClientTokenProvider, HttpServerPrincipalExtractor, PrincipalWithScopes. Topics: Kora Framework, Kora OpenAPI, openapi-generator, OpenAPI code generation, contract-first, API client generation.
- [OpenAPI management](https://kora-projects.github.io/kora-docs/v2/en/documentation/openapi-management/): Explains the Kora OpenAPI management module that publishes OpenAPI contract files and the Swagger UI and Scalar viewer pages through the public HTTP server. Use when working with OpenApiManagementModule, OpenApiManagementConfig, openapi.management.files, CacheMode, Swagger UI, Scalar. Topics: Kora Framework, Kora OpenAPI, Swagger UI, Scalar, API documentation, OpenAPI viewer.
- [Common](https://kora-projects.github.io/kora-docs/v2/en/documentation/database-common/): Common Kora database model shared by the JDBC and Cassandra modules: entities, identifiers, naming, embedded fields, query parameters, SQL macros, batch queries, affected rows, several databases in one application, and query telemetry. Use when working with @Repository, @Query, @Table, @Column, @Id, @Embedded, @Batch, @Mapping and UpdateCount. Topics: Kora Framework, Kora repository, Kora database, SQL macros, entity mapping, batch queries.
- [JDBC](https://kora-projects.github.io/kora-docs/v2/en/documentation/database-jdbc/): Explains Kora JDBC repositories, the jdbc configuration section, Hikari pool tuning, result and parameter mapping, generated identifiers, manual queries built with JdbcQuery, transactions and isolation levels, and the PostgreSQL module with array, collection, interval, range and JSON column mappers. Use when working with @Repository, @Query, @EntityJdbc, @Table, @Id, @Column, @Batch, JdbcDatabaseModule, PostgresJdbcDatabaseModule, @Pg, @PgJson, @PgJsonb, PgRange. Topics: Kora Framework, Kora JDBC, JDBC repository, HikariCP, SQL transactions, PostgreSQL, PostgreSQL arrays, PostgreSQL range types, PostgreSQL JSONB.
- [Cassandra](https://kora-projects.github.io/kora-docs/v2/en/documentation/database-cassandra/): Explains Kora Cassandra repositories, Cassandra driver configuration, execution profiles, entity and UDT mapping, manual CQL queries, and repository signatures. Use when working with @Repository, @Query, @EntityCassandra, @Table, @Id, @Column, @UDT, CassandraDatabaseModule, CassandraExecutor. Topics: Kora Framework, Kora Cassandra, Apache Cassandra, CQL, UDT mapping, Cassandra driver.
- [Migration](https://kora-projects.github.io/kora-docs/v2/en/documentation/database-migration/): Explains Kora database migration modules for Flyway and Liquibase, migration configuration, startup behavior, DBMS dialect artifacts, and JDBC integration. Use when working with FlywayJdbcDatabaseModule, LiquibaseJdbcDatabaseModule, FlywayJdbcDatabaseInterceptor, LiquibaseJdbcDatabaseInterceptor, FlywayConfig, LiquibaseConfig, JdbcDataSource. Topics: Kora Framework, Kora migrations, Flyway, Liquibase, database migration, JDBC.
- [Kafka](https://kora-projects.github.io/kora-docs/v2/en/documentation/kafka/): Explains Kora Kafka consumers and producers, listener and publisher annotations, configuration, serialization, error handling, rebalance events, transactions, and telemetry with TRACE payload logging and masking. Use when working with @KafkaListener, @KafkaPublisher, @KafkaPublisher.Topic, @Json, @Tag, KafkaModule, KafkaListenerConfig, KafkaPublisherConfig, TransactionalPublisher, telemetry.logging.maskHeaders, MaskingStrategy, DataMasker, JsonDataMasker, DefaultKafkaConsumerBodyConverter. Topics: Kora Framework, Kora Kafka, @KafkaListener, @KafkaPublisher, Kafka consumer Java, Kafka transactions, Kafka log masking.
- [gRPC server](https://kora-projects.github.io/kora-docs/v2/en/documentation/grpc-server/): Explains the Kora gRPC server: protobuf Gradle plugin setup, GrpcServerConfig options, unary and streaming StreamObserver handlers, io.grpc.Status error handling, the virtual-thread execution model, ServerInterceptor interceptors and their order, TLS through ServerCredentials, builder tuning through Configurer, lifecycle and readiness, telemetry and reflection. Use when working with GrpcServerModule, GrpcServerConfig, Configurer, ServerCredentials, ServerInterceptor, StreamObserver, reflectionEnabled, Server Reflection, MaskingStrategy, maskHeaders. Topics: Kora Framework, Kora gRPC server, grpc-java, protobuf, gRPC interceptors, virtual threads, gRPC telemetry masking.
- [gRPC client](https://kora-projects.github.io/kora-docs/v2/en/documentation/grpc-client/): Explains the Kora gRPC client: the grpc-client module, protobuf Gradle plugin setup, the grpcClient configuration section, injecting generated stubs, per-client interceptors, TLS credentials, channel tuning and telemetry. Use when working with GrpcClientModule, GrpcClientConfig, GrpcClientChannelFactory, ManagedChannelLifecycle, ChannelCredentials, protobuf plugin, MaskingStrategy, maskHeaders. Topics: Kora Framework, Kora gRPC client, gRPC stubs, grpc-java, gRPC TLS, protobuf, gRPC telemetry masking.
- [Resilience](https://kora-projects.github.io/kora-docs/v2/en/documentation/resilient/): Explains Kora resilience aspects built on typed specification interfaces: circuit breakers, retries with backoff/jitter/budget, timeouts, rate limiters (token bucket or fixed window, local or Redis-backed distributed), distributed retry budgets, fallback methods, exception filtering, telemetry, configuration, and supported signatures. Use when working with @CircuitBreakable, @Retryable, @Timeout, @RateLimited, @Fallback, @CircuitBreakerSpec, @RetrySpec, @TimeoutSpec, @RateLimiterSpec, @RateLimiterDistributedSpec, NonRetryableException, NonCircuitableException, RetryBudgetFactory, ResilientModule, LettuceDistributedResilientModule. Topics: Kora Framework, Kora resilience, circuit breaker Java, retry backoff, rate limiter, distributed rate limiter, retry budget, fault tolerance.
- [Cache](https://kora-projects.github.io/kora-docs/v2/en/documentation/cache/): Explains Kora cache module, cache annotations, Caffeine and Redis cache backends, cache key mapping, telemetry, invalidation, execution modes and supported method signatures. Use when working with @Cache, @Cacheable, @CachePut, @CacheInvalidate, @CacheInvalidateAll, @CacheMode, CaffeineCacheModule, LettuceRedisCacheModule, CacheKeyMapper, LoadableCache. Topics: Kora Framework, Kora cache, Caffeine, Redis cache, @Cacheable, cache invalidation.
- [Validation](https://kora-projects.github.io/kora-docs/v2/en/documentation/validation/): Explains the Kora validation constraint annotations, class and method validation, argument and result validation, configuration validation, custom constraints, mapping validation failures to HTTP 400, and supported validation signatures. Use when working with @Valid, @Validate, @ValidatedBy, @NotBlank, @NotEmpty, @Pattern, @Size, @OneOf, @UUID, @Uri, @Url, @Range, @Min, @Max, @Positive, @Negative, @Digits, @Past, @Future, @AssertTrue, ValidatorModule, ValidationModule. Topics: Kora Framework, Kora validation, constraint annotations, method validation, bean validation alternative, HTTP 400.
- [Scheduling](https://kora-projects.github.io/kora-docs/v2/en/documentation/scheduling/): Explains Kora scheduling for the JDK, Quartz and db-scheduler schedulers, fixed rate, fixed delay, one-shot and cron jobs, triggers, virtual-thread execution, persistent database jobs, graceful shutdown, and concurrency controls. Use when working with @ScheduleJdkAtFixedRate, @ScheduleJdkWithFixedDelay, @ScheduleJdkOnce, @ScheduleJdkWithCron, @ScheduleQuartzWithTrigger, @DisallowConcurrentExecution, @PersistJobDataAfterExecution, SchedulingJdkModule, SchedulingJdkExecutor, VirtualThreadSchedulingJdkExecutor, CronExpression, QuartzModule, DbSchedulerModule, DbSchedulerConfig, KoraDbScheduler, DbSchedulerJob. Topics: Kora Framework, Kora scheduling, cron jobs Java, Quartz, db-scheduler, scheduled tasks, @ScheduleJdkAtFixedRate, virtual threads.
- [Logging](https://kora-projects.github.io/kora-docs/v2/en/documentation/logging-aspect/): Explains Kora logging aspects for argument and result logging, selective logging, structured JSON values, value masking, raw payload masking, MDC enrichment and supported signatures. Use when working with @Log, @Log.in, @Log.out, @Log.result, @Log.off, @Mask, @Mdc, MaskingRules, MaskingPathRules, DataMasker, JsonDataMasker, XmlDataMasker, FormUrlencodedDataMasker, MaskingStrategy, StructuredArgument, StructuredArgumentMapper, MDC. Topics: Kora Framework, Kora @Log, logging aspect, data masking, MDC, compile-time AOP.
- [JUnit5](https://kora-projects.github.io/kora-docs/v2/en/documentation/junit5/): Explains the Kora JUnit 5 test extension: application graph tests, component injection, tags, Mockito and MockK mocks, test configuration, container modification and lifecycle. Use when working with @KoraAppTest, @TestComponent, KoraAppGraph, KoraAppTestConfigModifier, KoraConfigModification, KoraAppTestGraphModifier, KoraGraphModification, @MockitoStrictness. Topics: Kora Framework, Kora JUnit 5, @KoraAppTest, Mockito, MockK, Java testing.
- [GraalVM Native](https://kora-projects.github.io/kora-docs/v2/en/documentation/graalvm-native/): Explains how to build a Kora application into a GraalVM Native Image: the Gradle plugin and JDK 25 toolchain, the fat JAR and the two-stage Docker build, reachability metadata, and how to verify the resulting binary. Use when working with GraalVM, native-image, nativeCompile, reachability metadata, reflect-config.json, AOT, native build. Topics: Kora Framework, Kora GraalVM, GraalVM Native Image, native Java, Docker, fast startup.
- [Netty](https://kora-projects.github.io/kora-docs/v2/en/documentation/netty/): Explains the shared Kora Netty transport: event loop groups, transport selection between NIO, EPOLL, KQUEUE and io_uring, channel factory and thread factories. Use when working with NettyModule, NettyTransportConfig, NettyChannelFactory, NettyEventLoopFactory, EventLoopGroup. Topics: Kora Framework, Kora Netty, Netty, EPOLL, io_uring, event loop.
- [S3 client](https://kora-projects.github.io/kora-docs/v2/en/documentation/s3-client/): Explains the two independent Kora S3 artifacts: the declarative s3-client-kora client built on Kora's own HTTP client and the s3-client-aws wrapper that publishes the AWS SDK S3Client. Covers @S3.Client, @S3.Bucket, @S3.Get, @S3.Head, @S3.List, @S3.Put, @S3.Delete, request arguments, response models, configuration, exceptions and testing. Topics: Kora Framework, Kora S3, S3 client Java, AWS SDK S3, object storage, declarative client.
- [Camunda BPMN](https://kora-projects.github.io/kora-docs/v2/en/documentation/camunda7-bpmn/): Explains Kora Camunda 7 BPMN embedded process engine integration, resource deployment, delegates, engine services, transactions, configuration, and telemetry. Use when working with CamundaEngineBpmnModule, CamundaEngineBpmnConfig, ProcessEngine, JavaDelegate, KoraDelegate, CamundaTransactionManager, ProcessEngineConfigurator, Metrics Reference. Topics: Kora Framework, Kora Camunda, Camunda 7, BPMN, process engine, workflow Java.
- [Camunda REST](https://kora-projects.github.io/kora-docs/v2/en/documentation/camunda7-rest/): Explains how Kora exposes the Camunda 7 REST API over a dedicated Undertow HTTP server, with OpenAPI, Swagger UI and Scalar pages, CORS, telemetry, and graceful shutdown. Use when working with CamundaRestUndertowModule, CamundaRestModule, CamundaRestConfig, CamundaRest, KoraProcessEngineProvider, camunda.rest, CORS, telemetry. Topics: Kora Framework, Kora Camunda REST, Camunda 7 REST API, Undertow, Swagger UI, BPMN.
- [Camunda Zeebe](https://kora-projects.github.io/kora-docs/v2/en/documentation/camunda8-worker/): Explains Kora Camunda 8 Zeebe worker integration, CamundaClient configuration, job handling, variables, telemetry, and supported handler signatures. Use when working with @JobWorker, @JobVariable, @JobVariables, CamundaClient, JobContext, KoraJobWorker, JobWorkerException, ZeebeWorkerModule, ZeebeClientConfig, ZeebeWorkerConfig. Topics: Kora Framework, Kora Camunda 8, Zeebe, @JobWorker, Camunda client, workflow automation.
- [Development](https://kora-projects.github.io/kora-docs/v2/en/community/development/): Lists developments and extensions for Kora created by the community, currently the Kora plugin for IntelliJ IDEA that shows dependency injection points and their implementations in Kora DI. Use when looking for community-made tooling around Kora or for IDE support for Kora DI. Topics: Kora Framework, Kora IntelliJ plugin, IntelliJ IDEA, Kora community, IDE support.
- [Changelog](https://kora-projects.github.io/kora-docs/v2/en/changelog/changelog/) Topics: Kora Framework, Kora changelog, Kora 2.0, release notes, migration guide.

## Blog

- [Kora Framework Blog](https://kora-projects.github.io/kora-docs/v2/en/blog/): Articles about the Kora Framework — its design, compile-time approach, practical backend development, integrations, performance, and operating JVM services in production. Topics: Kora Framework, Kora blog, Java backend framework, Kotlin backend framework, compile-time dependency injection, virtual threads, microservices.
- [You Don't Need Kora Developers — You Need Good JVM Engineers](https://kora-projects.github.io/kora-docs/v2/en/blog/you-need-good-jvm-engineers/): Kora builds on JDBC, SQL, Kafka, HTTP, OpenAPI, OpenTelemetry and PostgreSQL skills strong JVM engineers already have — a transferability map for hiring. Topics: Kora Framework, JVM engineers, hiring backend developers, SQL skills, PostgreSQL, OpenTelemetry, Java and Kotlin.
- [You Don't Need Kora Developers: Skills vs Vendor Lock-In](https://kora-projects.github.io/kora-docs/v2/en/blog/you-dont-need-kora-developers/): Why “no Kora developers on the market” misreads hiring: strong JVM engineers become productive in Kora fast, and their skills stay portable, not locked in. Topics: Kora Framework, hiring Java developers, vendor lock-in, transferable skills, JVM engineers, framework adoption, team onboarding.
- [Kora vs Jakarta EE: Portability or Directness?](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-instead-of-jakarta-ee/): Jakarta EE optimizes for portable specifications across vendors; Kora for direct, explicit JVM backends. CDI, interceptors, persistence, REST and hosting compared. Topics: Kora Framework, Kora vs Jakarta EE, Jakarta EE, CDI, JAX-RS, JPA, Java EE alternative, application server.
- [Why Choose Kora Over Spring for a New JVM Backend](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-over-spring-for-backend/): A greenfield Kora vs Spring comparison: compile-time guarantees, virtual threads by default, thinner architecture and lower framework overhead for new services. Topics: Kora Framework, Kora vs Spring, Spring Boot alternative, JVM backend framework, greenfield microservices, virtual threads, compile-time DI.
- [Why Kora: A Compile-Time Framework for the Modern JVM](https://kora-projects.github.io/kora-docs/v2/en/blog/why-kora-compile-time-framework/): Kora moves dependency injection, HTTP adapters, repositories and AOP into compilation — what compile-time certainty means for startup, overhead and debugging. Topics: Kora Framework, compile-time framework, Java framework, Kotlin framework, annotation processing, no runtime reflection, fast startup.
- [Compile-Time Is Not Enough: Rethinking the Framework Model](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-rethinks-framework-model-itself/): Moving DI and AOP to compile time doesn't remove Spring-style complexity. Kora goes further by reducing how much framework model needs to exist at all. Topics: Kora Framework, compile-time framework, framework design, cognitive load, accidental complexity, Spring programming model, virtual threads.
- [Why Kora May Be the Right Default for Your Next JVM Backend](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-right-default-for-backend/): A pragmatic case for Kora as the default JVM backend framework: compile-time validation, explicit architecture, virtual threads and focused production modules. Topics: Kora Framework, choosing a JVM framework, Java backend framework, Kotlin backend framework, compile-time validation, virtual threads, microservices.
- [Why Most Backend Services Don't Need an ORM](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-dont-need-orm/): Why Kora repositories over native SQL fit most services better than Hibernate-style ORMs — N+1, dirty tracking, hidden queries — and when an ORM is still right. Topics: Kora Framework, Kora repositories, ORM vs SQL, Hibernate alternative, JPA, native SQL, JDBC repository, N+1 problem.
- [Why Compile-Time Frameworks Work Well With AI Coding Agents](https://kora-projects.github.io/kora-docs/v2/en/blog/neuro-agent-and-kora/): Kora's compile-time graph, explicit constructors, strong types and generated source give AI coding agents fast, precise compiler feedback instead of startup mysteries. Topics: Kora Framework, AI coding agents, LLM code generation, agentic coding, compile-time validation, strong typing, generated source.
- [Why Compile-Time Diagnostics Are a Feature, Not Build Overhead](https://kora-projects.github.io/kora-docs/v2/en/blog/compile-time-diagnostics/): Kora validates the application graph and generates readable code during the build, turning DI and wiring mistakes into precise compiler errors for IDEs, CI and AI. Topics: Kora Framework, compile-time diagnostics, compiler errors, application graph validation, annotation processing, CI feedback, developer experience.
- [Where Framework Performance Actually Comes From](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-performance/): Kora's performance as a budget across compile time, startup and runtime: generated wiring, prepared routes, fast mapping, JDBC repositories and virtual threads. Topics: Kora Framework, Java framework performance, JVM performance, startup time, throughput, TechEmpower benchmark, virtual threads.
- [Virtual Threads vs Reactive Programming in JVM Backends](https://kora-projects.github.io/kora-docs/v2/en/blog/virtual-thread-vs-reactive/): Kora's virtual-thread-first model vs reactive stacks: API shape, stack traces and debugging, context propagation, JDBC vs reactive drivers, and backpressure. Topics: Kora Framework, virtual threads vs reactive, Project Reactor, Spring WebFlux, reactive drivers, backpressure, Java concurrency.
- [Virtual Threads in Production: Pinning, Carriers, Load Spikes](https://kora-projects.github.io/kora-docs/v2/en/blog/virtual-thread-in-production/): How virtual threads behave under real load in Kora services: pinning, carrier starvation, connection pools as backpressure, Little's Law and overload control. Topics: Kora Framework, virtual threads in production, thread pinning, carrier threads, connection pool, Little's Law, backpressure.
- [Virtual Threads First: Why Kora Is Synchronous Again](https://kora-projects.github.io/kora-docs/v2/en/blog/virtual-thread-first/): Why Kora 2 is virtual-thread-first: synchronous controllers, HTTP clients and JDBC repositories without reactive types, and what Loom does not make free. Topics: Kora Framework, virtual threads, Project Loom, synchronous programming, reactive programming, JDBC, Java concurrency.
- [Thin Abstractions: Staying Close to JDBC, Kafka, gRPC and HTTP](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-abstractions/): How Kora removes integration boilerplate while keeping plain SQL, Kafka records, grpc-java stubs and HTTP semantics visible — easier debugging, upgrades and hiring. Topics: Kora Framework, thin abstractions, JDBC, Apache Kafka, gRPC Java, HTTP, framework design, leaky abstractions.
- [The Myth of the Large Framework Ecosystem](https://kora-projects.github.io/kora-docs/v2/en/blog/myth-of-large-community/): Why community size and Stack Overflow volume aren't framework features, how stale tutorials mislead AI, and what to evaluate in a backend framework like Kora. Topics: Kora Framework, framework ecosystem, developer community, Stack Overflow, choosing a framework, outdated tutorials, AI answers.
- [An Easier Framework to Learn: Reusing the JVM You Know](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-easier-to-learn/): Why Kora is quick to learn: JDBC, SQL, Kafka, gRPC, HTTP and OpenTelemetry stay as they are, so Java and Kotlin knowledge transfers instead of being replaced. Topics: Kora Framework, learning Kora, Java backend framework, Kotlin backend, JDBC, OpenTelemetry, developer onboarding.
- [Extending a Framework Ecosystem Should Be Simple](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-extending-framework-ecosystem/): A walkthrough integrating NATS into Kora with @Module, typed configuration and lifecycle — showing how any Java library can join the application graph. Topics: Kora Framework, Kora @Module, framework extensibility, NATS Java client, library integration, typed configuration, component lifecycle.
- [The Real Cost of a Missing Framework Integration](https://kora-projects.github.io/kora-docs/v2/en/blog/cost-of-missing-integration/): Why Kora doesn't need a starter for every library: typed config, @Module factories, explicit lifecycle and health probes keep integrating any Java client cheap. Topics: Kora Framework, Kora @Module, library integration, Spring Boot starters, typed configuration, health checks, Java client libraries.
- [The Best Framework for AI Agents Has the Least Magic](https://kora-projects.github.io/kora-docs/v2/en/blog/neuro-agent-best-native-kora-framework/): Hidden causality — runtime proxies, classpath-driven defaults, reflection — confuses AI agents. Why explicit compile-time frameworks like Kora are safer to change. Topics: Kora Framework, AI agents, framework magic, hidden causality, runtime proxies, classpath scanning, agentic coding.
- [The Application Graph as Executable Architecture in Kora](https://kora-projects.github.io/kora-docs/v2/en/blog/application-graph-as-architecture/): Kora's compile-time application graph is more than DI wiring: a validated, inspectable map of dependencies, lifecycle, modules and infrastructure. Topics: Kora Framework, Kora application graph, compile-time dependency injection, software architecture, component lifecycle, Java backend, Kotlin backend.
- [Testing the Same Application Graph You Run in Production](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-test-graph/): How Kora's JUnit 5 extension builds test graphs from the production graph: component slices, in-graph mocks, typed configuration and the real lifecycle. Topics: Kora Framework, Kora testing, JUnit 5, integration testing, component tests, mocking, Java testing.
- [Structured Concurrency with StructuredTaskScope in Kora](https://kora-projects.github.io/kora-docs/v2/en/blog/structured-concurrency-in-kora/): How Java's StructuredTaskScope fits Kora's synchronous virtual-thread model: local fan-out, failure propagation, cancellation, deadlines and observability. Topics: Kora Framework, structured concurrency, StructuredTaskScope, virtual threads, Project Loom, Java concurrency, fan-out.
- [Kora vs Spring: A Modern JVM Backend Through the STEP Lens](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-vs-spring-through-step-lens/): Kora and Spring compared on simplicity, transparency, efficiency and predictability: where compile-time Kora wins for greenfield and where Spring's breadth decides. Topics: Kora Framework, Kora vs Spring, Spring Boot comparison, JVM framework comparison, compile-time DI, runtime proxies, virtual threads.
- [STEP: Simple, Transparent, Efficient, Predictable](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-step/): The STEP principles behind Kora and how they tie compile-time DI, generated code, virtual threads and telemetry into one coherent backend framework design. Topics: Kora Framework, Kora STEP principles, framework design principles, simplicity, transparency, predictability, backend engineering.
- [Startup vs Build Time: Moving Framework Work Left](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-startup-vs-build-time/): Why Kora shifts framework work from every JVM startup into the build, and what that trade means for deployments, tests, autoscaling and CI build times. Topics: Kora Framework, startup time, build time, annotation processing, shift left, runtime reflection, JVM startup.
- [Production Knowledge Built Into the Framework](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-production-knowledge-built-in/): How Kora bakes operational practice into defaults — telemetry, resilience, readiness probes, graceful shutdown, latency and resource efficiency for high-load services. Topics: Kora Framework, production readiness, high load, graceful shutdown, readiness probes, SRE practices, cloud-native Java.
- [Policy-Driven Resilience, Caching, Validation and Scheduling](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-infra-and-funcs/): How Kora attaches retries, circuit breakers, timeouts, caching, validation and scheduled jobs as declarative policies generated at compile time — and how they compose. Topics: Kora Framework, resilience, circuit breaker, retry, caching, validation, scheduling, compile-time AOP.
- [Performance You Don't Need Still Saves Money](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-save-money-and-time/): Why framework efficiency matters without peak load: CPU, memory baseline, reserve capacity, redundancy and multi-region fleets multiply Kora's lower footprint. Topics: Kora Framework, cloud cost optimization, JVM memory footprint, CPU efficiency, FinOps, microservice fleet, Kubernetes resources.
- [OpenAPI-First Development: The Contract as Source of Truth](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-openapi-development/): Contract-first OpenAPI in Kora generates typed servers, clients, models and error responses, so API changes become compile errors instead of runtime drift. Topics: Kora Framework, OpenAPI, contract-first API, OpenAPI code generation, REST API, HTTP client generation, API design.
- [One STEP at a Time: Why AI Agents Iterate Well in Kora](https://kora-projects.github.io/kora-docs/v2/en/blog/neuro-agents-kora-step/): How Kora's STEP design — simple, transparent, efficient, predictable — makes each AI agent iteration produce verifiable evidence instead of guesswork. Topics: Kora Framework, Kora STEP principles, AI coding agents, agent feedback loop, generated source, virtual threads, agentic development.
- [One Problem, One Solution: Fewer Framework Abstractions](https://kora-projects.github.io/kora-docs/v2/en/blog/one-problem-one-solution/): Why Kora keeps one canonical path per problem — synchronous concurrency, one DI graph, SQL, typed config — and how that eases onboarding, upgrades and AI agents. Topics: Kora Framework, framework design, canonical path, maintainability, developer onboarding, cognitive load, typed configuration.
- [Observability by Design: One Request Across the Stack](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-observability/): How Kora threads logs, metrics and OpenTelemetry traces through one request across HTTP, database, clients and messaging, with consistent context propagation. Topics: Kora Framework, observability, OpenTelemetry, distributed tracing, metrics, structured logging, context propagation.
- [No Runtime Magic: What Kora Actually Generates](https://kora-projects.github.io/kora-docs/v2/en/blog/no-runtime-magic/): A walk through the Java and Kotlin code Kora generates from annotations: the application graph, HTTP handlers, JSON readers and writers, JDBC repositories and AOP. Topics: Kora Framework, annotation processing, generated code, no runtime reflection, JSON serialization, JDBC repositories, HTTP controllers.
- [Learning a Backend Framework in the AI Era](https://kora-projects.github.io/kora-docs/v2/en/blog/neuro-era-learning-framework/): Learning shifted from memorizing framework lore to reasoning from evidence — docs, generated source and compiler errors. Why Kora is built for this model. Topics: Kora Framework, learning Kora, AI-assisted learning, compiler errors, generated source, developer onboarding, strong typing.
- [Kora Skill: The Missing Layer Between Docs and AI Agents](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-skill-between-docs-and-agent/): How the official Kora skill gives AI coding agents canonical, navigable framework context — fewer hallucinated APIs and less non-idiomatic generated code. Topics: Kora Framework, Kora skill, AI coding agents, agent skills, LLM hallucinations, AI-assisted development, Claude Code.
- [Kora: A Framework That Became AI-Native by Accident](https://kora-projects.github.io/kora-docs/v2/en/blog/neuro-native-framework-kora-became/): Kora was designed for developer experience, not LLMs — yet compile-time DI, explicit registration and generated sources make it easy for AI agents to verify. Topics: Kora Framework, AI-native framework, AI coding agents, compile-time DI, generated sources, LLM-friendly code, agentic coding.
- [In the AI Era, Framework Expertise Beats Community Size](https://kora-projects.github.io/kora-docs/v2/en/blog/neuro-era-framework-matters-more-community/): AI makes answers cheap and verification the bottleneck. Why explicit compile-time frameworks like Kora, with reviewable generated code, outweigh community size. Topics: Kora Framework, AI-assisted development, developer community, code verification, generated code, framework selection, LLM.
- [When a Million Answers Are a Warning Sign](https://kora-projects.github.io/kora-docs/v2/en/blog/million-answers-a-warning-sign/): Why a huge Q&A corpus can signal hidden framework complexity, not just a healthy ecosystem — and how Kora aims for behavior you can derive from the code itself. Topics: Kora Framework, framework complexity, Stack Overflow, developer community, framework magic, documentation, cognitive load.
- [How to Build Your Own Kora Module: A Step-by-Step Guide](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-build-your-module/): Build a first-class Kora module for any Java library: typed configuration, construction through compile-time DI, lifecycle, telemetry, health checks and tests. Topics: Kora Framework, Kora module, @Module, custom integration, typed configuration, OpenTelemetry, Java library integration.
- [An HTTP Request's Path Through Kora on Virtual Threads](https://kora-projects.github.io/kora-docs/v2/en/blog/http-request-throught-kora/): Follow one HTTP request through Kora: Undertow I/O threads, dispatch to a virtual thread, generated handler, controller and JDBC — and why blocking is fine here. Topics: Kora Framework, virtual threads, Project Loom, Undertow, HTTP server, JDBC, Java concurrency, request lifecycle.
- [How Generated Code Makes Framework Debugging Transparent](https://kora-projects.github.io/kora-docs/v2/en/blog/generated-code-transparent-debugging/): Kora generates readable Java and Kotlin sources for DI, HTTP handlers, repositories and AOP, so you can step through real framework behavior in the debugger. Topics: Kora Framework, generated source code, Java debugging, annotation processing, KSP, IDE debugger, AOP, framework transparency.
- [Focused Engineering Is Not NIH Syndrome](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-focused-engineering-is-not-nih/): Why Kora reuses JDBC, Kafka, gRPC and OpenTelemetry, yet owns the parts that need framework context: type safety, compile-time generation, predictable behavior. Topics: Kora Framework, NIH syndrome, framework design, build vs reuse, JDBC, Apache Kafka, OpenTelemetry.
- [Fast JVM Startup Is Capacity, Not Just Convenience](https://kora-projects.github.io/kora-docs/v2/en/blog/fast-startup-not-convenience/): Why startup time and time-to-readiness drive rolling deploys, autoscaling, scale-to-zero and cloud cost — and how Kora removes startup work from JVM services. Topics: Kora Framework, JVM startup time, time to readiness, Kubernetes autoscaling, HPA, scale to zero, cold start, cloud cost.
- [Enterprise-Ready Without a Framework Universe](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-enterprise-ready-without-universe/): How Kora delivers enterprise essentials — observability, resilience, lifecycle, OpenAPI contracts, security — by reusing the JVM ecosystem instead of rebuilding it. Topics: Kora Framework, enterprise Java, production readiness, OpenTelemetry, OpenAPI, resilience, Spring ecosystem alternative.
- [Does Compile-Time Code Generation Slow Development Down?](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-compile-time-and-development-speed/): Measuring Kora's annotation processing honestly: clean vs incremental builds, the Gradle daemon, submodules, and why generated DI and repositories keep feedback fast. Topics: Kora Framework, annotation processing performance, compile-time code generation, Gradle incremental build, build speed, KSP, developer productivity.
- [Documentation Maturity: Coverage, Structure and Signal](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-documentation-maturity/): Why framework documentation quality depends on coverage of functionality, layered structure and signal, not age or page count — and how Kora's docs are organized. Topics: Kora Framework, Kora documentation, documentation quality, technical documentation, reference docs, guides and examples, framework maturity.
- [Framework Documentation in the AI Era: Beyond Pages](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-documentation-in-the-ai-era/): Why reference docs, guides, runnable examples, generated source and compiler feedback form one knowledge system in Kora — and why that matters for AI assistants. Topics: Kora Framework, Kora documentation, documentation for AI, LLM coding assistants, runnable examples, developer documentation, AI-assisted development.
- [Do Production Services Need a Dynamic Application Graph?](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-dynamic-runtime-refresh/): Kora keeps the application graph static at compile time while ValueOf<T> enables config refresh, log levels, feature flags and dynamic behavior at runtime. Topics: Kora Framework, ValueOf, configuration refresh, feature flags, runtime reconfiguration, application graph, dynamic configuration.
- [Component vs Integration vs Black-Box Tests on the JVM](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-testing-different-approaches/): What component, integration and black-box tests each prove in a Kora service, and how to place every test at the cheapest boundary that can catch the failure. Topics: Kora Framework, test pyramid, component tests, integration tests, black-box testing, JUnit 5, testing strategy.
- [Compile-Time DI at Scale: Fast Builds for Large Kora Projects](https://kora-projects.github.io/kora-docs/v2/en/blog/compile-time-di-at-scale-kora/): How @KoraSubmodule and Gradle modules keep Kora's compile-time dependency injection fast in large codebases: incremental builds and clear module boundaries. Topics: Kora Framework, @KoraSubmodule, compile-time DI, Gradle multi-module build, incremental compilation, build performance, large Java projects.
- [Compile-Time Dependency Injection in Kora: How It Works](https://kora-projects.github.io/kora-docs/v2/en/blog/compile-time-dependency-injection/): How Kora resolves and validates the dependency graph at compile time: @KoraApp, @Component, @Module, tags, All<T>, ValueOf<T>, lifecycle and build errors. Topics: Kora Framework, Kora dependency injection, compile-time DI, annotation processing, KSP, @KoraApp, @Module, Java DI framework.
- [Compile-Time AOP Without Dynamic Proxies in Java](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-aop/): How Kora implements AOP with generated subclasses instead of runtime proxies: compile-time validation, readable interceptors, self-invocation and performance. Topics: Kora Framework, Kora AOP, aspect-oriented programming, compile-time AOP, dynamic proxies, self-invocation, Spring AOP alternative, annotation processing.
- [A Strong Default Is Not Lock-In: A Framework Built to Extend](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-strong-default-not-lock-in/): Kora's opinionated defaults stay replaceable: @DefaultComponent, opt-in modules and @Module let you swap generated components and add integrations in one graph. Topics: Kora Framework, vendor lock-in, @DefaultComponent, extensibility, opinionated framework, @Module, dependency injection.
- [Why Kora May Be the Best Kind of Framework for Kotlin](https://kora-projects.github.io/kora-docs/v2/en/blog/kora-may-be-best-for-kotlin/): Kora pairs Kotlin with KSP compile-time processing, preserved nullability and virtual threads instead of suspend contracts — Kotlin stays Kotlin on the backend. Topics: Kora Framework, Kotlin backend framework, KSP, Kotlin coroutines, virtual threads, Kotlin null safety, Kotlin server-side.
- [A Compile-Time Framework Doesn't Ban Reflection Libraries](https://kora-projects.github.io/kora-docs/v2/en/blog/compile-time-not-libraries/): Kora avoids reflection internally, yet apps can still use JVM libraries built on reflection or proxies — and why GraalVM Native Image is a separate question. Topics: Kora Framework, compile-time framework, Java reflection, dynamic proxies, GraalVM Native Image, HotSpot JVM, JVM libraries.
- [The Price of a “PhD in Spring” and How Kora Lowers It](https://kora-projects.github.io/kora-docs/v2/en/blog/talk-joker-phd-in-spring-talk/): Joker talk companion: the hidden framework knowledge developers carry — lifecycle, configuration precedence, test context caching, aspects — and Kora's alternative. Topics: Kora Framework, Spring complexity, Spring Boot configuration, Spring test context caching, Spring AOP, Joker conference, cognitive load.
- [Kora in Practice: What a Real JVM Framework Benchmark Revealed](https://kora-projects.github.io/kora-docs/v2/en/blog/talk-benchmark-others-and-kora/): Talk companion: a developer new to Kora benchmarked it against familiar JVM frameworks. The setup, throughput and resource results, and the lessons learned. Topics: Kora Framework, JVM framework benchmark, Spring WebFlux, performance comparison, resource consumption, microservice benchmark, conference talk.
- [Beyond “Spring Magic”: Transparency and Lower Cognitive Load](https://kora-projects.github.io/kora-docs/v2/en/blog/talk-jvm-day-cognitive-load/): JVM Day 2024 talk companion: type-safe DI, explicit lifecycle and modules, compile-time guarantees and generated code — how Kora reduces cognitive load. Topics: Kora Framework, Spring magic, cognitive load, type-safe dependency injection, compile-time guarantees, JVM Day 2024, conference talk.
- [Why Kora Was Built: Pre-1.0 Architecture and Benchmarks](https://kora-projects.github.io/kora-docs/v2/en/blog/talk-kora-why-build-pre-1.0-origin/): Pre-1.0 talk companion: where Spring, Quarkus and Micronaut fell short, the Undertow + JDBC baseline, early benchmarks and ideas that survived in Kora. Topics: Kora Framework, Kora history, Spring vs Quarkus vs Micronaut, Undertow, JVM benchmarks, startup memory, microservices.