Library / SDK
slick/slick avatar
slick/slick

Slick: nine databases, two 4.0.0 candidates, and one stable docs path

Slick (Scala Language Integrated Connection Kit) is a modern database query and access library for Scala

2,666 stars611 forksScalaBSD-2-Clause

At a glance

What is it?
The Scala database access library keeps its schema explicit and its effect type polymorphic over Cats Effect 3, while the docs link labelled stable is offered as the route to the latest release.
Who is it for?
Slick is worth checking if you want SQL generated from Scala with an explicit, code-generatable schema and an effect type you choose, because the Async plus FS2 pairing is the part that makes it fit a Typelevel stack. Verify three things first.
Can I use it commercially?
Yes. BSD-2-Clause is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 1 day ago.
What is it written in?
Mainly Scala, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • slick/slick2,666 ★ · +1
Star history
Repository2026-10-042026-11-15
slick/slick2.7k2.7k

1 Stars in the last 42 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The only worked example stops on a half written SQL comment

The Example section is the one place the project shows code, and it is short. It declares a case class, maps it to a table, and creates a TableQuery, then goes on to insert with `coffees += Coffee("Latte", 2.50)`, fetch with `coffees.map(_.name)`, and filter and sort with `coffees.filter(_.price < 10.0).sortBy(_.name)`, each preceded by a comment giving the SQL it generates. The mapping part, reproduced below, shows that the schema is declared by hand as a class extending Table with a tag and a table name, columns are typed through column calls against named SQL identifiers, the projection is a tuple mapped into the case class, and the query object is a TableQuery value.

scala
import slick.jdbc.PostgresProfile.api.*

// First declare our Scala object
final case class Coffee(name: String, price: Double)

// Next define how Slick maps from a database table to Scala objects
class Coffees(tag: Tag) extends Table[Coffee](tag, "COFFEES") {
  def name  = column[String]("NAME")
  def price = column[Double]("PRICE")
  def * = (name, price).mapTo[Coffee]
}

// The `TableQuery` object gives us access to Slick's rich query API
val coffees = TableQuery[Coffees]

Four of the nine listed databases have an empty tested server column

The support table claims the listed engines are currently covered by a large suite of automated tests to ensure compatibility, and then leaves the tested server version blank for four of its nine rows: Derby and JavaDB, H2, HSQLDB, and SQLite. The five rows that do fill the column are also uneven. PostgreSQL and MySQL are both marked Latest, SQLServer is pinned to 2022, Oracle to 11g, and DB2 to 11.5.7.0. The driver coordinates are just as uneven. Most rows carry a numeric version, but the DB2 row lists its version as `db2jcc4`, which is a name rather than a number, and the SQLServer row carries a `jre11` suffix that picks a Java 11 build. The Oracle row is the one to look at twice: its coordinate is a 21.21.0.0 build of a driver whose artifact is named `ojdbc8_g` under a group id ending in `.debug`, tested against a server column reading 11g. So the table's claim of broad coverage and its per row detail do not line up. The text around the table draws a second line that the rows themselves do not: engines listed as directly supported, and everything else, which stays reachable but with possibly a reduced feature set. The blank cells therefore sit inside the supported set rather than at its edge, and the reduced feature set applies only to the databases the table declines to claim.

The compose file at the root publishes five database services with their credentials in the file

docker-compose.yml at the repository root is a test fixture with five services, and every credential it needs is written in plain text. Postgres runs with POSTGRES_PASSWORD set to postgres. MySQL sets MYSQL_ALLOW_EMPTY_PASSWORD to yes. SQLServer sets MSSQL_SA_PASSWORD to Freeslick18 and requests eight cpus. Oracle passes ORACLE_PASSWORD as oracle. DB2 passes DB2INST1_PASSWORD and DB2INSTANCE, sets LICENSE to accept, and runs with privileged set to true. All five publish host ports, so a developer running this file has Postgres on 5432, MySQL on 3306, DB2 on 50000, SQLServer on 1401, and Oracle on 49161. Nothing here is a production secret and nothing in the file marks these values as development only. One deliberate safeguard is spelled out in a comment on the DB2 healthcheck: a db2 connect probe would leak CLP connections and break the testkit schema cleanup, so readiness is read from a marker file the image touches after activating the database, with retries of 60 at ten second intervals behind a ninety second start period. The directories around the file say what it is for: common-test-resources/ and test-dbs/ sit at the root beside it, and slick-testkit/ is a module of its own. So this is a test harness rather than a deployment recipe, which is the context in which a root level compose file with empty passwords and a privileged container belongs.

The link labelled stable is offered as the path to the latest release

The Learn section says full documentation is on the website and then says that for the latest release you can go straight to scala-slick.org/doc/stable/. Two things sit behind that sentence. The tag list holds v4.0.0-RC2 dated 2026-09-07 and v4.0.0-RC1 dated 2026-06-19, both release candidates for the same major version, and the last tag that is not a candidate is v3.6.1 from 2025-05-16. So the two candidate releases sit roughly sixteen months after the most recent ordinary tag. A path named stable, offered as the way to the latest release, is the sort of path that tracks the last non-prerelease line, which would make it a pointer to the 3.x documentation while the 4.0.0 candidates are the current line. The file does not say which line stable follows. Anyone who reads that sentence as an instruction to get the newest documentation may land one major version behind the code they are about to depend on, and the tag list is the only place the two lines can be told apart. The homepage in the project metadata is the same domain, so the two urls differ by a single path segment and nothing else announces which line sits behind it.

The group id says com.typesafe.slick while the import root says slick

The import in the example is slick.jdbc.PostgresProfile, and the published coordinate in the badge block is com.typesafe.slick with the artifact slick_2.13. The group id and the package root are therefore not the same string, and a reader who assumes the coordinate mirrors the package will reach for the wrong artifact name. The Scala version has the same problem from the other direction. 2.13 appears twice in the file and both times inside a badge: once in the shields.io image path for the Maven central version, and once in a link to mvnrepository.com/artifact/com.typesafe.slick/slick_2.13. No sentence of prose states which Scala version the page is describing, so the version a reader would put in a build file is carried entirely by an image URL and a link target. That link is also the only plain http address in the badge block, where the sponsor, discussions, Discord, and Gitter links are all https. The project is described as community-maintained with a Lightbend code of conduct, so the lingering TypeSafe coordinate is a historical artifact rather than a sign of who owns the code today.

Two dependency bots, a merge bot, and a CLAUDE.md share the root

The root is unusually crowded with automation config. .scala-steward.conf and renovate.json are both present, so dependency bumps are delegated to two separate update services. .mergify.yml adds a third actor that acts on merges rather than versions, and .github/ sits beside all three. Two editor and agent oriented files are tracked as well, .vscode/ and CLAUDE.md, plus .jvmopts for the build JVM and testVersions.sc for the version matrix. Build metadata is split across build.sbt at the root, project/ for the build definition itself, and versionPolicy.sbt as a separate file, which is where a binary compatibility policy might be declared. Nothing in the README mentions any of this. For a library the relevant part is the version policy file, because it decides whether a patch release can change a signature that downstream code already compiles against, and a reader has to find that file rather than being told it exists. Seven modules, two update services, a merge bot, and a version policy file is the arrangement you would expect from a project whose compiled output lands inside other people's builds.

Seven slick- modules sit in the tree and four of them are never named

The build is a multi-module one, and the module directories at the top level are slick/, slick-codegen/, slick-compat-collections/, slick-future/, slick-hikaricp/, slick-testkit/, and slick-zio/. The feature list in the README names none of them. It says the schema representation can be code-generated from the actual database without pointing at slick-codegen, mentions ZIO Task as an example effect type without pointing at slick-zio, and says nothing at all about a connection pool even though slick-hikaricp is a module of its own. slick-testkit is the one module the visible text touches indirectly, through the compose file comment about testkit schema cleanup, and slick-compat-collections and slick-future are not mentioned anywhere either. This matters for dependency selection rather than for reading the docs: whether the code generator, the pool, and the ZIO support ship inside the main artifact or arrive as separate modules changes what goes on the classpath, and the feature list presents all of it as one library.

Three support channels stay open while one is preferred and a single sponsor slot sits at the top

The help section keeps three channels alive and ranks them. Questions go to GitHub Discussions, or to the slick channel on the official Scala Discord server, and there is a Gitter channel too, with Discord named as the preferred one. Bugs go to GitHub issues. Licensing is BSD-2-Clause in LICENSE.txt at the root, and the conduct rules are the Lightbend Community Code of Conduct, which the project asks contributors to abide by while describing itself as community-maintained and noting that Lightbend staff may be able to help with administrative issues. Above all of that sits a sponsor block with a single slot: the badge is labelled for one named account and the link identifier is numbered Sponsor1, as if a series had been started and one seat filled. Maintenance signal comes from elsewhere. The tag list has no 4.0.0 final release, only the two candidates, so anyone reading the project as shipped software is reading a prerelease line.

Editorial conclusion

Slick is worth checking if you want SQL generated from Scala with an explicit, code-generatable schema and an effect type you choose, because the Async plus FS2 pairing is the part that makes it fit a Typelevel stack. Verify three things first. The project overview's example is short, so the docs site rather than this page is where the query patterns live. The support table claims a large automated test suite while four of its nine rows carry no tested server version at all, and the Oracle row pairs a 21.x driver with a server marked 11g. And the path the page calls the latest release is named stable, which may be a different line from the two 4.0.0 candidates in the tag list, so pin deliberately rather than following the link. Teams wanting a driverless API are looking at a different library.

Frequently asked questions

Which databases does Slick support directly?

Nine, each with a JDBC driver coordinate: PostgreSQL on org.postgresql 42.7.10, MySQL on com.mysql mysql-connector-j 9.6.0, SQLServer on mssql-jdbc 13.4.0.jre11, Oracle on ojdbc8_g 21.21.0.0, DB2, Derby, H2, HSQLDB, and SQLite. The table says they are covered by a large suite of automated tests, though four rows leave the tested server version blank.

What effect types does the Slick async API accept?

The asynchronous API is built on Cats Effect 3, and db.run(action) returns F[R] for any effect type with a cats.effect.Async instance, with cats.effect.IO and ZIO Task named as examples. The streaming API returns an FS2 Stream[F, T] instead, so streaming composition goes through the Typelevel ecosystem rather than a bespoke type.

How does Slick map a Scala object to a database table?

By hand or by generation. The example declares a case class, then a class extending Table with a tag and the table name COFFEES, typed columns against the SQL identifiers NAME and PRICE, and a projection defined as a tuple mapped into the case class. A TableQuery value gives access to the query API, and the schema can also be code-generated from the actual database.

Which Slick release should a new dependency target?

That is not settled by the project's own page. The recent tags are v4.0.0-RC2, v4.0.0-RC1, and v3.6.1, so two candidates exist for 4.0.0 while the last tag that is not a candidate is v3.6.1 from 2025-05-16. The page also points at a docs path named stable as the route to the latest release without saying which line it follows.

Where do I find Slick documentation and support?

Full documentation and scaladocs are on scala-slick.org, with a separate path for the latest release. Questions go to GitHub Discussions or the slick channel on the official Scala Discord server, a Gitter channel also exists with Discord preferred, and bugs go to GitHub issues. There is also a free guide to using the library from first principles.

How is Slick maintained and licensed?

It is described as community-maintained, with pull requests welcome, under a BSD-2-Clause license in LICENSE.txt and the Lightbend Community Code of Conduct, and Lightbend staff noted as possibly able to help with administrative issues. The root also carries renovate.json and .scala-steward.conf, so two services handle dependency updates.

Official sources

  1. License: BSD-2-Clause
  2. Project website
  3. README
  4. Releases
  5. slick/slick on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/slick-slick.svg)](https://hysenlabs.com/projects/slick-slick)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/slick-slick.svg)](https://hysenlabs.com/projects/slick-slick)

Was this useful?