Skip to content
CAI
Software that uses CAICheck a score

endless4s/endless

66.3

Adequate · 9 November 2026

4.5k

lines of production code

Scala

primary language

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Endless is a Scala library that provides abstractions for building event-sourced and durable entities using tagless-final algebras. It enables the deployment of these entities within distributed systems via runtime implementations for Akka and Apache Pekko Cluster Sharding. The system supports flexible serialization through Protobuf and Circe, allowing developers to define domain logic that persists state and handles side-effects across clustered nodes.

How it got here

2021 — rebranding to Endless and core library release

18 changes.

The project was rebranded to 'Endless' and rebuilt on Scala 2.13, introducing a new core event-sourcing library with foundational abstractions for durable entities. This period saw the removal of legacy persistence components, the addition of Pekko runtime support, and the implementation of serialization protocols for Circe and Protobuf. A comprehensive example application and extensive test coverage were also established to demonstrate the new architecture.

2022–2023 — Akka and Pekko runtime support

10 changes.

This period focused on introducing dedicated runtime modules for both Akka and Apache Pekko, enabling cluster-sharded deployment of event-sourced and durable repositories. The work included implementing necessary serialization, configuration, and lifecycle management for both frameworks, alongside expanding the example application to demonstrate multi-runtime compatibility and HTTP-based interaction.

Features

Add Circe-based JSON serialization for command protocols

The \circe\ module now provides a set of classes (\CirceCommandProtocol\, \CirceEncoder\, \CirceDecoder\, \CirceIncomingCommand\, \CirceOutgoingCommand\) that integrate the Circe library into the core command protocol. This allows users to serialize and deserialize commands and replies using Circe's JSON encoders and decoders, replacing the need for manual or alternative serialization implementations within this module.

circe/src/main · high confidence

Add Pekko runtime example alongside existing Akka example

The example application now includes a dedicated Pekko implementation (PekkoApp.scala and Main.scala) in addition to the existing Akka implementation. This allows users to run the same domain logic (Bookings and Vehicles) using the Apache Pekko actor framework, demonstrating support for multiple runtime backends within the same codebase structure.

example/src/main/scala/endless/example/app/pekko · high confidence

Add booking and vehicle domain models and adapters

The example application now includes protobuf definitions and Scala adapters for booking and vehicle entities. New protocol buffer schemas define commands, events, replies, and state for both domains, enabling structured communication for operations like placing or canceling bookings and managing vehicle speed and position. Corresponding adapter classes in the Scala adapter layer handle serialization and deserialization between internal domain objects and the protobuf journal formats, supporting durable entity persistence for these new capabilities.

example/src/main/protobuf, example/src/main/scala/endless/example/adapter · high confidence

Add data models for vehicle and booking domain

The example application now includes core domain data structures in the \endless.example.data\ package, introducing \Booking\ and \Vehicle\ entities along with supporting types like \LatLon\, \Speed\, and \BookingEvent\. These models define the shape of booking requests (including origin, destination, and status) and vehicle state (position, speed, and recovery count), providing the foundational data layer for the example's vehicle endpoints and durable entity logic.

example/src/main/scala/endless/example/data · high confidence

Add protocol implementations for Booking and Vehicle command handling

The example application now includes concrete protocol handlers for Booking and Vehicle domains. BookingCommandProtocol implements the client-side interface for placing, retrieving, modifying, and cancelling bookings, mapping protobuf messages to domain algebra operations. VehicleCommandProtocol provides both server-side decoding and client-side sending for vehicle commands such as setting speed/position and retrieving vehicle state, enabling the example to demonstrate durable entity interactions with these specific command/reply patterns.

example/src/main/scala/endless/example/protocol · high confidence

Added Pekko runtime configuration with cluster and serialization settings

A new reference.conf file has been added to the pekko-runtime module, establishing default configurations for the Pekko actor system. This includes setting the actor provider to cluster, defining custom serializers for Command and Reply data types, and binding these serializers to specific classes. Additionally, the configuration enables the JVM to exit automatically when the cluster performs a coordinated shutdown after a split-brain resolver decision.

pekko-runtime/src/main/resources · high confidence

Added example configuration for Akka and Pekko runtime support

The example application now includes dedicated configuration files (akka.conf and pekko.conf) that allow it to run on either the Akka or Apache Pekko actor framework. These configurations set up cluster providers, remote transports on distinct ports (61000 for Akka, 51000 for Pekko), and enforce message serialization using ScalaPB for specific domain events like BookingEvent and VehicleStateV1. A unified application.conf includes both, and logback.xml is configured to provide detailed DEBUG-level logging for cluster sharding components to aid in development and debugging.

example/src/main/resources · high confidence

Added official project logo assets

The \logo\ directory now contains the project's official branding assets, including a full logo (\logo.svg\), a symbol-only variant (\logo-symbol-only.svg\), and an Open Graph image (\logo-open-graph.svg\). These SVG files provide the visual identity for the project across documentation, social sharing previews, and general use.

logo · high confidence

Bootstrap documentation website with new site template and content

The documentation site is now bootstrapped with a new HTML template (\page.st\) that includes Open Graph meta tags for better social sharing and updated assets for the Paradox Material Theme. The site content has been expanded to include comprehensive guides on core abstractions (Entity, DurableEntity, Effector, Deployer), a getting-started section with dependency instructions, and an example application walkthrough featuring sequence diagrams.

documentation · high confidence

Initial release of the Endless event-sourcing core library

The library has been rebranded from Akka Persistence Tagless to Endless, with core types and packages migrated from \akka.persistence.tagless\ to \endless.core\. This release introduces the foundational abstractions for building event-sourced and durable entities, including \Entity\ and \DurableEntity\ traits for state management, \Deployer\ and \DurableDeployer\ for assembling repository runtimes, and \EntityT\/\DurableEntityT\ monad transformers for interpreting command handlers. It also provides the protocol layer (\CommandProtocol\, \CommandSender\) for distributed entity communication, interpreters for behavior and side-effects, and helper utilities like \StateReaderHelpers\ and \EventsFolder\ to streamline entity logic.

core/src/main/scala/endless · high confidence

Introduce Akka runtime for cluster-sharded event-sourced and durable repositories

This change adds the \akka-runtime\ module, providing the concrete Akka-based implementation for deploying and running entities within an Akka Cluster Sharding environment. It introduces serializers for internal command and reply payloads using Protobuf, a resource-managed Akka cluster lifecycle with coordinated shutdown support, and deployers for both standard event-sourced and durable state repositories. Users can now deploy their repositories to Akka clusters, where commands are routed via sharding, side-effects are triggered on specific lifecycle events (recovery, persistence, reads), and passivation is handled automatically.

akka-runtime/src/main/scala · high confidence

Introduce Pekko runtime for cluster-sharded entity deployment

This change adds the \pekko-runtime\ module, providing the infrastructure to deploy and run entities using Apache Pekko Cluster Sharding. It includes Protobuf definitions and serializers for command/reply payloads, a \ShardingCommandSender\ for inter-entity communication, and \PekkoDeployer\/\PekkoDurableDeployer\ traits that wire up event-sourced and durable-state behaviors to the Pekko cluster. The runtime manages the actor system lifecycle via a \Resource\, handles passivation, and supports differentiated side-effect run modes (sync vs async) triggered by recovery, persistence, or read events.

pekko-runtime/src/main/scala · high confidence

Introduce Protobuf command protocol integration

Adds a new set of Scala components in the protobuf module that enable serializing and deserializing commands and replies using Protocol Buffers (via scalapb). This includes a ProtobufCommandProtocol trait for sending and handling commands, ProtobufEncoder and ProtobufDecoder objects for byte conversion, and specific command wrappers (ProtobufOutgoingCommand, ProtobufIncomingCommand). A test suite with a dummy proto definition validates the end-to-end flow of sending a command and receiving a reply.

protobuf · high confidence

Introduce example application with booking and vehicle entity logic

Adds the initial example application code in the logic package, implementing domain-specific behaviors for bookings and vehicles. This includes \BookingEntityBehavior\ and \BookingEventApplier\ to handle booking state transitions (placing, changing origin/destination, canceling, accepting/rejecting), and \BookingSideEffect\ to manage post-recovery availability checks and passivation. Similarly, \VehicleEntityBehavior\ and \VehicleSideEffect\ provide logic for updating vehicle speed and position, tracking recovery counts, and enforcing aggressive passivation. The setup also includes sharding wrappers (\ShardedBookings\, \ShardedVehicles\) to expose these entities via a sharded actor model.

example/src/main/scala/endless/example/logic · high confidence

New HTTP server implementation for the example application

The example application now includes a new HttpServer component that exposes REST endpoints for managing bookings and vehicle telemetry. Users can create, retrieve, update, and cancel bookings, as well as query and set vehicle speed, position, and recovery counts via an HTTP4s server backed by Blaze.

example/src/main/scala/endless/example/app · high confidence

New example algebra interfaces for availability, booking, and vehicle management

The example application now includes a set of new algebraic interfaces in the \endless.example.algebra\ package to define the core domain capabilities. \AvailabilityAlg\ provides a method to check capacity availability for a given time and passenger count. \BookingAlg\ defines the operations for managing individual bookings, including placing, retrieving, modifying origins/destinations, cancelling, and receiving capacity notifications, along with associated error types like \BookingAlreadyExists\ and \CancelError\. \BookingsAlg\ serves as a factory to retrieve specific booking algebras by ID. Similarly, \VehicleAlg\ exposes methods to control vehicle speed and position, retrieve current state, and manage recovery counts, while \VehiclesAlg\ acts as the factory for vehicle algebras by ID. These traits establish the functional interfaces used by the example's durable entities.

example/src/main/scala/endless/example/algebra · high confidence

Removals

Removal of core persistence algebra and runtime partitioning components

The core persistence algebra and its runtime integration have been removed. This includes the deletion of the \EntityT\ and \RepositoryT\ interpretation layers, the \EventsFolder\ and \Folded\ data structures, and the \Entity\, \Repository\, \Command\, and \Partitioner\ typeclasses. The \ShardPartitioner\ runtime implementation for Akka Cluster Sharding has also been removed, along with the \Bookings\ example application that demonstrated these capabilities.

core/src/main/scala/akka, example/src/main/scala/akka, runtime · high confidence

Behavioural changes

Added Akka cluster configuration with coordinated shutdown settings

A new reference configuration file has been added for the Akka runtime, defining cluster actor provider settings and custom serializers for Command and Reply data types. It also explicitly sets coordinated-shutdown.exit-jvm to on, ensuring the JVM exits when the cluster removes a node after a split-brain resolver decision.

akka-runtime/src/main/resources · high confidence

Introduce implementation traits for Availabilities, Bookings, and Vehicles

The application now defines specific implementation traits in the \app.impl\ package to wire together core domain components. The \Availabilities\ trait provides a mock availability check that logs status and simulates a delay, while the \Bookings\ and \Vehicles\ traits establish the necessary implicit protocols, entity name providers, ID codecs, and event/state adapters required for their respective command handling. This structure supports the underlying goal of enabling multiple concurrent runtime instances.

example/src/main/scala/endless/example/app/impl · high confidence

Project rebranded to 'endless' with Scala 2.13 support and updated documentation

The project has been rebranded as 'endless', a Scala library for describing event-sourced entities using tagless-final algebras with implementations for Akka and Pekko. The build configuration has switched from Scala 3 to Scala 2.13 (updating .scalafmt.conf and README badges), and the documentation site has been bootstrapped with new contributing guidelines, a code of conduct, and updated release processes.

(repo-wide) · high confidence

Test coverage

Added test coverage for CirceCommandProtocol; Added test coverage for the example application; Added test suites for Effector and StateReaderHelpers; Added tests for EntityT and DurableEntityT interpretation; Added tests for Pekko Protobuf serialization with Scala 3 support; Added tests for ScalaPbSerializer with Scala 3 support.

Dependencies

Major dependency and build toolchain upgrades

The project has significantly upgraded its core libraries and build infrastructure. Key dependency updates include Akka to 2.6.21, Cats to 2.13.0, Cats-Effect to 3.7.1, http4s to 0.23.37, and Circe to 0.14.16. The build system has been upgraded from sbt 1.5.4 to 1.13.0, with corresponding updates to plugins such as sbt-wartremover (2.4.16 to 3.6.1), sbt-scoverage (1.8.2 to 2.4.4), and the addition of sbt-version-policy and sbt-ci-release. Additionally, ScalaPB support has been added via the sbt-protoc plugin.

project · high confidence

Upgrade to Scala 3.9.0 and add Pekko runtime support

The build system has been updated to support Scala 2.13.18 and Scala 3.9.0, replacing the previous Scala 2.13.3 baseline. A new \pekko-runtime\ module has been introduced alongside the existing \akka-runtime\, allowing users to choose between Akka and Pekko for persistence backends. The project structure has also been expanded with new helper modules for Circe and Protobuf, and the core library now includes additional test dependencies like \cats-effect\ and \munit\.

(dependencies) · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 58 → 66 (+8.4)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 98 → 98 (+0.0)
  • Architecture 98 → 98 (+0.0)
  • Maturity 39 → 62 (+23.3)
  • Readiness 61 → 68 (+7.0)
  • Security 75 → 58 (-16.7)
  • Performance 100 → 100 (+0.0)

Resolved (4)

  • Dependency hygiene PARTLY measured — sbt declarations read, dependency currency not (Maven Central unreachable)
  • Documentation: no installation or build instructions (README.md)
  • Documentation: no usage examples (README.md)
  • Off-boarding risk: anonymized user #1

New (6)

  • Off-boarding risk: anonymized user #1
  • Outdated: ch.qos.logback:logback-classic
  • Outdated: org.http4s:http4s-blaze-client_2.13
  • Outdated: org.http4s:http4s-blaze-server_2.13
  • Outdated: org.http4s:http4s-circe_2.13
  • Outdated: org.http4s:http4s-dsl_2.13

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

endless4s/endless was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 9 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 7152af646a76e80da40f7a73d18894689f5a71c0 — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-bb0cb800cd0f.