Scala
made by https://0x3d.site
GitHub - plokhotnyuk/jsoniter-scala: Scala macros for compile-time generation of safe and ultra-fast JSON codecs + circe boosterScala macros for compile-time generation of safe and ultra-fast JSON codecs + circe booster - plokhotnyuk/jsoniter-scala
Visit Site
GitHub - plokhotnyuk/jsoniter-scala: Scala macros for compile-time generation of safe and ultra-fast JSON codecs + circe booster
jsoniter-scala
Scala macros for compile-time generation of safe and ultra-fast JSON codecs.
Latest results of benchmarks on JVMs that compare parsing and serialization performance of jsoniter-scala with: borer, circe, circe with jsoniter-scala booster, jackson-module-scala, json4s-jackson, json4s-native, play-json, play-json with jsoniter-scala booster, smithy4s-json, spray-json, uPickle, weePickle, zio-json libraries using different JDK and GraalVM versions on the following environment: Intel® Core™ i9-13900K CPU @ 3.0GHz (max 5.8GHz, performance-cores only), RAM 64Gb DDR5-4800, Ubuntu 24.04 (Linux 6.8), and latest versions of JDK 17/21/24-ea, GraalVM Community JDK 17/21/24-ea, and GraalVM JDK 17/21/24-ea*.
Latest results of benchmarks on browsers that compare performance of jsoniter-scala with: circe, circe with jsoniter-scala booster, play-json, play-json with jsoniter-scala booster, smithy4s-json, uPickle, zio-json compiled by Scala.js 1.17.0 to ES 2015 with GCC v20220202 optimizations applied on Intel® Core™ i7-11800H CPU @ 2.3GHz (max 4.6GHz), RAM 64Gb DDR4-3200, Ubuntu 23.10 (Linux 6.8).
Contents
Acknowledgments
This library had started from macros that reused jsoniter (json-iterator) for Java reader and writer but then the library evolved to have its own core of mechanics for parsing and serialization.
The idea to generate codecs by Scala macros and main details were borrowed from Kryo Macros (originally developed by Alexander Nemish) and adapted for the needs of the JSON domain.
Other Scala macros features were peeped in AVSystem Commons and magnolia libraries.
Ideas for the most efficient parsing and serialization of java.time.*
values were inspired by
DSL-JSON's implementation for java.time.OffsetDateTime
.
Other projects and a blog post that have helped deliver unparalleled safety and performance characteristics for parsing and serialization of numbers:
- Schubfach - the most efficient and concise way to serialize doubles and floats to the textual representation
- rust-lexical - the most efficient way to parse floats and doubles from the textual representation precisely
- big-math - parsing of
BigInt
andBigDecimal
values with theO(n^1.5)
complexity instead ofO(n^2)
using Java's implementations wheren
is a number of digits - James Anhalt's algorithm - the ingenious algorithm for printing integers into decimal strings
A bunch of SWAR technique tricks for JVM platform are based on following projects and a blog post:
- borer - the fast parsing of JSON strings by 8-byte words
- simdjson - the fast checking of string for digits by 8-byte words
- FastDoubleParser - the fast parsing of numbers by 8-byte words
- Johnny Lee's article - the fast time string to seconds conversion
Big kudos to all contributors:
Goals
- Safety: validate parsed values safely with the fail-fast approach and clear reporting, provide configurable limits for suboptimal data structures with safe defaults to be resilient for DoS attacks, generate codecs that create instances of a fixed set of classes during parsing to avoid RCE attacks
- Correctness: support the latest JSON format (RFC-8259), do not replace illegally encoded characters of string values by placeholder characters, parse numbers with limited binary representation doing half even rounding for too long JSON numbers, serialize floats and doubles to the shortest textual representation without loosing of precision
- Speed: do parsing and serialization of JSON directly from UTF-8 bytes to your data structures and back, do it crazily fast without using of runtime reflection or runtime code generation, intermediate ASTs, hash maps, but with minimum allocations and copying
- Productivity: derive codecs recursively for complex types using one line macro, do it in compile-time to
minimize the probability of run-time issues, optionally print generated sources as compiler output to be inspected for
proving safety and correctness or to be reused as a starting point for the implementation of custom codecs, prohibit
serializing of
null
Scala values and parsing immediately to them in generated codecs - Ergonomics: have preconfigured defaults for the safest and common usage that can be easily altered by compile- and run-time configuration instances, combined with compile-time annotations and implicits, embrace the textual representation of JSON providing a pretty printing option, provide a hex dump in the error message to speed up the view of an error context
Features and limitations
- JSON parsing from
String
,Array[Byte]
,java.nio.ByteBuffer
,java.io.InputStream
/java.io.FileInputStream
- JSON serialization to
String
,Array[Byte]
,java.nio.ByteBuffer
,java.io.OutputStream
/java.io.FileOutputStream
- Support of parsing from or writing to part of
Array[Byte]
orjava.nio.ByteBuffer
by specifying of position and limit - Parsing of streaming JSON values and JSON arrays from
java.io.InputStream
/java.io.FileInputStream
without the need of holding all input and parsed values in the memory - Only UTF-8 encoding is supported when working with buffered bytes directly but there is a fallback to parse and
serialize JSON from/to
String
(while this is much less efficient) - Parsing of strings with escaped characters for JSON keys and string values
- Codecs can be generated for primitives, boxed primitives, enums, tuples,
String
,BigInt
,BigDecimal
,Option
,Either
,java.util.UUID
,java.time.*
(to/from ISO-8601 representation only), Scala collections, arrays (including immutable arrays in Scala 3), module classes, literal types, value classes, and case classes with values/fields having any of types listed here - Classes should be defined with a primary constructor that hasn't defined default values in non-first parameter lists
- Non-case Scala classes also supported, but they should have getter accessors for all arguments of a primary constructor
- Types that supported as map keys are primitives, boxed primitives, enums,
String
,BigInt
,BigDecimal
,java.util.UUID
,java.time.*
, literal types, and value classes for any of them - Codecs for sorted maps and sets can be customized by implicit
Ordering[K]
instances for keys that are available at the scope of themake
macro call - Core module support reading and writing byte arrays from/to Base16 and Base64 representations (RFC 4648) for using in custom codecs
- Parsing of escaped characters is not supported for strings which are mapped to byte arrays, numeric and
java.time.*
types - Support of first-order and higher-kind types
- Support of 2 representations of ADTs with a sealed trait or a Scala class as a base type and non-abstract Scala classes or objects as leaf classes: 1st representation uses discriminator field with string type of value, 2nd one uses string values for objects and a wrapper JSON object with a discriminator key for case class instances
- Implicitly resolvable value codecs for JSON values and key codecs for JSON object keys that are mapped to maps allows to inject your custom codecs for adding support of other types or for altering representation in JSON for already supported classes
- Type aliases are supported for all types mentioned above
- Only acyclic graphs of class instances are supported by generated codecs
- Order of instance fields is preserved during serialization for generated codecs
- Throws a parsing exception if duplicated keys were detected for a class instance (except maps)
- Serialization of
null
values is prohibited by throwing ofNullPointerException
errors - Parsing of
null
values allowed only for optional or collection types (that means theNone
value or an empty collection accordingly) and for fields which have defined non-null default values - Fields with default values that defined in the constructor are optional, other fields are required (no special annotation required)
- Fields with values that are equals to default values, or are empty options/collections/arrays are not serialized to provide a sparse output
- Any values that used directly or as part of default values of the constructor parameters should have right
implementations of the
equals
method (it mostly concerns non-case classes or other types that have custom codecs) - Fields can be annotated as transient or just not defined in the constructor to avoid parsing and serializing at all
- Field names can be overridden for serialization/parsing by field annotation in the primary constructor of classes
- Reading and writing of any arbitrary bytes or raw values are possible by using custom codecs
- Parsing exception always reports a hexadecimal offset of
Array[Byte]
,java.nio.ByteBuffer
,java.io.InputStream
/java.io.FileInputStream
where it occurs, and an optional hex dump affected by error part of an internal byte buffer - Configurable by field annotation ability to read/write numeric fields from/to string values
- Both key and value codecs are specialized to work with primitives efficiently without boxing/unboxing
- No extra buffering is required when parsing from
java.io.InputStream
/java.io.FileInputStream
or serializing tojava.io.OutputStream
/java.io.FileOuputStream
- Using black box macros only for codec generation ensures that your types will never be changed
- Ability to print generated code for codecs using an implicit val of
CodecMakerConfig.PrintCodec
type in a scope of codec derivation - No dependencies on extra libraries in runtime excluding Scala's
scala-library
(all platforms) andscala-java-time
(replacement of JDKsjava.time._
types for Scala.js and Scala Native) - On Scala.js and Scala Native platforms, if you need support for timezones besides
UTC
then you should follow the scala-java-time documentation for adding a time zone database to your application - Codecs and runtime configurations implement
java.io.Serializable
for easier usage in distributive computing - Support of shading to another package for locking on a particular released version
- Patch versions are backward and forward compatible, minor versions are backward compatible
- Integration with circe for faster parsing/serialization and decoding/encoding to/from circe AST
- Releases for different Scala versions: 2.12, 2.13, and 3.3
- Support of JVMs for Java 11+ versions
- Support of compilation to a native image by GraalVM
- Support of Scala.js 1.0+ for all supported Scala versions
- Support of Scala Native 0.5+ for all supported Scala versions
- Suppressing of all WartRemover warnings of generated codecs for Scala 2.12 and 2.13
There are configurable options that can be set in compile-time:
- Ability to read/write numbers from/to string values
- Ability to read/write maps as JSON arrays
- Skipping of unexpected fields or throwing of parse exceptions
- Skipping of serialization of fields that have empty collection values can be turned off to force serialization of them
- Skipping of serialization of fields that have empty optional values can be turned off to force serialization of them
- Skipping of serialization of fields which values are matched with defaults that are defined in the primary constructor can be turned off to force serialization of that values
- Ability to require collection fields in the JSON input
- Ability to require fields with default values in the JSON input
- Ability to override names of classes of ADTs and fields using a compile-time annotation
- Mapping functions from names of classes and their fields to JSON keys or from names of Java enumeration values to JSON strings and back, including predefined functions which enforce snake_case, kebab-case, camelCase or PascalCase names for all fields in the generated codec
- An optional name of the discriminator field for ADTs
- Mapping function for values of a discriminator field that is used for distinguishing classes of ADTs
- Ability to set a precision, a scale limit, and the max number of significant digits when parsing
BigDecimal
values - Ability to set the max number of significant digits when parsing
BigInt
values - Ability to set the max allowed value when parsing bit sets
- Ability to set the limit for the number of inserts when parsing sets or maps
- Throwing of a compilation error for recursive data structures can be turned off
- Throwing of a runtime error when the discriminator is not the first field can be turned off
- Ability to parse/serialize Scala enumeration from/to id numbers
- Ability to derive codecs that can distinguish
null
field values and missing fields asSome(None)
andNone
values ofOption[Option[_]]
- Ability to turn on circe-like encoding of Scala objects in ADTs
- Ability to disable generation of implementation for decoding or encoding
- Ability to require fields that have defined default values
- Ability to generate smaller and more efficient codecs for classes when checking of field duplication is not needed
- Ability to inline non value classes which have the primary constructor with just one argument
List of options that change parsing and serialization in runtime:
- Serialization of strings with escaped Unicode characters to be ASCII compatible
- Indenting of output and its step
- Throwing of stack-less parsing exceptions by default to greatly reduce the impact on performance, while stack traces can be turned on in development for debugging
- Turning off hex dumping affected by error part of an internal byte buffer to reduce the impact on performance
- Size of the hex dump can be adjusted for bigger or smaller number of 16-byte lines
- Max size of internal input buffers when parsing from
java.io.InputStream
orjava.nio.DirectByteBuffer
- Preferred size of internal input buffers when parsing from
java.io.InputStream
orjava.nio.DirectByteBuffer
- Preferred size of internal output buffers when serializing to
java.io.OutputStream
orjava.nio.DirectByteBuffer
- Max size of char buffers when parsing string values
- Preferred size of char buffers when parsing string values
The v2.13.5.2 release is the last version that supports JDK 8+ and native image compilation with earlier versions of GraalVM.
The v2.13.3.2 release is the last version that supports Scala 2.11.
The v2.30.2 release is the last version that supports Scala Native 0.4+.
For upcoming features and fixes see Commits and Issues page.
How to use
Let's assume that you have the following data structures:
case class Device(id: Int, model: String)
case class User(name: String, devices: Seq[Device])
Add the core library with a "compile" scope and the macros library with "compile-internal" or "provided" scopes to your list of sbt dependencies:
libraryDependencies ++= Seq(
// Use the %%% operator instead of %% for Scala.js and Scala Native
"com.github.plokhotnyuk.jsoniter-scala" %% "jsoniter-scala-core" % "2.31.1",
// Use the "provided" scope instead when the "compile-internal" scope is not supported
"com.github.plokhotnyuk.jsoniter-scala" %% "jsoniter-scala-macros" % "2.31.1" % "compile-internal"
)
In the beginning of Scala CLI script use "dep" scope for the core library or "compileOnly.dep" scope for the macros libary:
//> using dep "com.github.plokhotnyuk.jsoniter-scala::jsoniter-scala-core::2.31.1"
//> using compileOnly.dep "com.github.plokhotnyuk.jsoniter-scala::jsoniter-scala-macros::2.31.1"
Derive a codec for the top-level type that need to be parsed or serialized:
import com.github.plokhotnyuk.jsoniter_scala.macros._
import com.github.plokhotnyuk.jsoniter_scala.core._
given userCodec: JsonValueCodec[User] = JsonCodecMaker.make
That's it! You have generated an instance of com.github.plokhotnyuk.jsoniter_scala.core.JsonValueCodec
for the
whole nested data structure. No need to derive intermediate codecs for inner nested classes like Device
if you are not
going to parse/serialize them from/to JSON in isolation (not as a part of User
) and use the default or the same
derivation configuration for their codecs.
Now use it for parsing and serialization from/to String
:
val user = readFromString[User]("""{"name":"John","devices":[{"id":1,"model":"HTC One X"}]}""")
val json = writeToString(User("John", Seq(Device(2, "iPhone X"))))
When your input comes from the network or disks much more efficient ways are to parse and serialize from/to:
- byte arrays using
readFromArray
/writeToArray
- byte sub-arrays using
readFromSubArray
/writeToSubArray
java.nio.ByteBuffer
instances usingreadFromByteBuffer
/writeToByteBuffer
java.io.InputStream
/java.io.OutputStream
instances usingreadFromStream
/writeToStream
Also, parsing from bytes will check UTF-8
encoding and throw an error in case of malformed bytes.
To print generated code for codecs add the following line to the scope of the codec derivation before make
call.
given CodecMakerConfig.PrintCodec with {}
For more use cases of jsoniter-scala, please, check out tests:
All Scala 3 only features are tested by specs in this directory.
NOTE: Until official docs will be published, please, use all these tests as tutorials and how-tos to help in your
journey to become happy users. Also, they are recommended to skim through for checking of your expectation before
selection of this library among others.
You can use the following on-line services to generate an initial version of your data structures from JSON samples:
Also, if you have JSON Schema the following on-line service can generate corresponding data structures for you:
And the following library can generate JSON Schema for your existing data structures:
Samples for its integration with different web frameworks and HTTP servers:
Usages of jsoniter-scala in OSS libraries:
- akka-http-json - integrates some of the best JSON libs in Scala with Akka HTTP
- bootzooka - a project to quickly start developing a Scala-based microservice or web app, without the need to write login, user registration etc.
- caliban - a purely functional library for building GraphQL servers and clients in Scala
- dijon - support of schema-less JSON using safe and efficient AST representation
- geo-scala - a core AST and utilities for GeoJSON (RFC 7946) and more
- iron - a lightweight library for refined types in Scala 3
- jsoniter-scala-circe - the circe
booster for faster parsing/serialization to/form circe AST and decoding/encoding of
java.time._
andBigInt
types - kafka-serde-scala - implicitly converts typeclass encoders to kafka Serializer, Deserializer, Serde
- logging4s - structured logging for Scala 3
- neotype - a friendly newtype library for Scala 3
- oath - yet another scala-jwt library which has the aim to enhance user experience
- pekko-http-json - integrates some of the best JSON libs in Scala with Pekko HTTP
- play-json-jsoniter - provides the fastest way to convert an
instance of
play.api.libs.json.JsValue
to byte array (or byte buffer, or output stream) and read it back - scalatest-json - Scalatest matchers with appropriate equality and descriptive error messages
- smithy4s-json - JSON protocol of Smithy tooling for Scala
- sttp - the Scala HTTP client you always wanted!
- sttp-oauth2 - OAuth2 client library implemented in Scala using sttp
- tapir - Typed API descRiptions
Also, for usages in other OSS projects see the Dependents
section of peoject's Scala Index page
For all dependent projects it is recommended to use sbt-updates plugin or Scala steward service to keep up with using of the latest releases.
Known issues
- There is no validation for the length of JSON representation during parsing.
If your system can accept too long untrusted input then check the input length before parsing with readFromStream
or other read...
calls.
Also, if you have an input that is an array of values or white-space separate values then consider parsing it by
scanJsonArrayFromInputStream
or scanJsonValuesFromInputStream
instead of readFromStream
.
- The configuration parameter for the
make
macro is evaluated in compile-time. It requires no dependency on other code that uses a result of the macro's call, otherwise the following compilation error will be reported:
[error] Cannot evaluate a parameter of the 'make' macro call for type 'full.name.of.YourType'. It should not depend on
code from the same compilation module where the 'make' macro is called. Use a separated submodule of the project
to compile all such dependencies before their usage for generation of codecs.
Sometime Scala 2 compiler can fail to compile the make
macro call with the same error message for the configuration
that has not clear dependencies on other code. For those cases workarounds can be simpler than recommended usage of
separated submodule:
- use
make
ormake...
macro calls without parameters - isolate the
make
macro call in the separated object, like in this PR - move jsoniter-scala imports to be local, like here and here
- use
sbt clean compile stage
orsbt clean test stage
instead of justsbt clean stage
, like in this repo - use
mill clean
if mill's native BSP support is used in IntelliJ IDEA
- Unexpected compiler errors can happen during compilation of ADT definitions or their derived codecs if they are nested in some classes or functions like here.
The workaround is the same for both cases: don't enclose ADT definitions into outer classes, traits or functions, use the outer object (not a class) instead.
- Compile-time configuration for
make
calls in Scala 3 has limited support of possible expressions for name mapping.
Please use examples of CodecMakerConfig
usage from unit tests.
- Unexpected parsing or serialization errors
can happen for nested parsing or serialization routines when the same instance of
JsonReader
orJsonWriter
is reused:
scanJsonValuesFromStream[String](in) { s =>
readFromString[String](s)
}
The workaround is using reentrant parsing or serialization routines for all except the most nested call. That will
create a new instance of JsonReader
or JsonWriter
on each reentrant call:
scanJsonValuesFromStreamReentrant[String](in) { s =>
readFromString[String](s)
}
- Scala.js doesn't support Java enums compiled from Java sources, so linking fails with errors like:
[error] Referring to non-existent class com.github.plokhotnyuk.jsoniter_scala.macros.Level
[error] called from private com.github.plokhotnyuk.jsoniter_scala.macros.JsonCodecMakerSpec.$anonfun$new$24()void
[error] called from private com.github.plokhotnyuk.jsoniter_scala.macros.JsonCodecMakerSpec.$anonfun$new$1()void
[error] called from constructor com.github.plokhotnyuk.jsoniter_scala.macros.JsonCodecMakerSpec.<init>()void
[error] called from static constructor com.github.plokhotnyuk.jsoniter_scala.macros.JsonCodecMakerSpec.<clinit>()void
[error] called from core module analyzer
The workaround for Scala 2 is to split sources for JVM and other platforms and use Java enum emulation for Scala.js and Scala Native.
Code for JVM:
public enum Level {
HIGH, LOW;
}
Code for Scala.js and Scala Native:
object Level {
val HIGH: Level = new Level("HIGH", 0)
val LOW: Level = new Level("LOW", 1)
val values: Array[Level] = Array(HIGH, LOW)
def valueOf(name: String): Level =
if (HIGH.name() == name) HIGH
else if (LOW.name() == name) LOW
else throw new IllegalArgumentException(s"Unrecognized Level name: $name")
}
final class Level private (name: String, ordinal: Int) extends Enum[Level](name, ordinal)
For Scala 3 the workaround can be the same for all platforms:
enum Level extends Enum[Level] {
case HIGH
case LOW
}
- Scala 3 compiler cannot derive anonymous codecs for generic types with concrete type parameters:
case class DeResult[T](isSucceed: Boolean, data: T, message: String)
case class RootPathFiles(files: List[String])
given JsonValueCodec[DeResult[Option[String]]] = JsonCodecMaker.make
given JsonValueCodec[DeResult[RootPathFiles]] = JsonCodecMaker.make
Current 3.2.x versions of scalac fail with the duplicating definition error like this:
[error] 19 | given JsonValueCodec[DeResult[RootPathFiles]] = JsonCodecMaker.make
[error] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[error] |given_JsonValueCodec_DeResult is already defined as given instance given_JsonValueCodec_DeResult
The workaround is using named instances of codecs:
given codecOfDeResult1: JsonValueCodec[DeResult[Option[String]]] = JsonCodecMaker.make
given codecOfDeResult2: JsonValueCodec[DeResult[RootPathFiles]] = JsonCodecMaker.make
or private type aliases with given
definitions gathered in some trait:
trait DeResultCodecs:
private type DeResult1 = DeResult[Option[String]]
private type DeResult2 = DeResult[RootPathFiles]
given JsonValueCodec[DeResult1] = JsonCodecMaker.make
given JsonValueCodec[DeResult2] = JsonCodecMaker.make
end DeResultCodecs
object DeResultCodecs extends DeResultCodecs
import DeResultCodecs.given
-
Currently, the
JsonCodecMaker.make
call cannot derive codecs for Scala 3 opaque and union types. The workaround is using a custom codec for these types defined withimplicit val
before theJsonCodecMaker.make
call, like here and here. -
If ADT leaf classes/object contains dots in their simple names the default name mapper will strip names up to the last dot character. The workaround is to use
@named
annotation like here:
sealed abstract class Version(val value: String)
object Version {
@named("8.10") case object `8.10` extends Version("8.10")
@named("8.09") case object `8.09` extends Version("8.9")
}
- When parsing JSON strings to numeric or
java.time.*
values escaped encoding of ASCII characters is not supported. The workaround is to use custom codecs which parse those values as strings and then convert them to corresponding types, like here:
implicit val customCodecOfOffsetDateTime: JsonValueCodec[OffsetDateTime] = new JsonValueCodec[OffsetDateTime] {
private[this] val defaultCodec: JsonValueCodec[OffsetDateTime] = JsonCodecMaker.make[OffsetDateTime]
private[this] val maxLen = 44 // should be enough for the longest offset date time value
private[this] val pool = new ThreadLocal[Array[Byte]] {
override def initialValue(): Array[Byte] = new Array[Byte](maxLen + 2)
}
def nullValue: OffsetDateTime = null
def decodeValue(in: JsonReader, default: OffsetDateTime): OffsetDateTime = {
val buf = pool.get
val s = in.readString(null)
val len = s.length
if (len <= maxLen && {
buf(0) = '"'
var bits, i = 0
while (i < len) {
val ch = s.charAt(i)
buf(i + 1) = ch.toByte
bits |= ch
i += 1
}
buf(i + 1) = '"'
bits < 0x80
}) {
try {
return readFromSubArrayReentrant(buf, 0, len + 2, ReaderConfig)(defaultCodec)
} catch {
case NonFatal(_) => ()
}
}
in.decodeError("illegal offset date time")
}
def encodeValue(x: OffsetDateTime, out: JsonWriter): Unit = out.writeVal(x)
}
- Do not use
implicit def
andinline given
methods for generation of custom codes. Scala 3.5.0+ shows compilation time warningNew anonymous class definition will be duplicated at each inline site
for someinline given
cases, but for other use cases the compiler will silently generate duplicated codec instances. To mitigate that convert methods of codec generation todef
and explicitly derive custom codecs, like here:
object Tags {
opaque type Tagged[+V, +T] = Any
type @@[+V, +T] = V & Tagged[V, T]
def tag[T]: [V] => V => V @@ Tag = [V] => (v: V) => v
}
object Graph {
import Tags.{@@, tag}
def tagJsonValueCodec[V, T](codec: JsonValueCodec[V]): JsonValueCodec[V @@ T] = new JsonValueCodec[V @@ T]:
//println("+1")
override def decodeValue(in: JsonReader, default: V @@ T): V @@ T = tag[T](codec.decodeValue(in, default: V))
override def encodeValue(x: V @@ T, out: JsonWriter): Unit = codec.encodeValue(x, out)
override def nullValue: V @@ T = tag[T](codec.nullValue)
trait NodeIdTag
type NodeId = Int @@ NodeIdTag
case class Node(id: NodeId, name: String)
case class Edge(node1: NodeId, node2: NodeId)
given JsonValueCodec[Graph.NodeId] = Graph.tagJsonValueCodec(JsonCodecMaker.make)
given JsonValueCodec[Graph.Node] = JsonCodecMaker.make
given JsonValueCodec[Graph.Edge] = JsonCodecMaker.make
}
How to develop
Feel free to ask questions in chat, open issues, or contribute by creating pull requests (improvements to docs, code, and tests are highly appreciated).
Currently, the gh-pages
branch contains a lot of historycal data of benchmark results, so to
avoid cloing 10Gb of them use --single-branch
branch option to fetch sources only.
If developing on a fork, make sure to download the git tags (required by the sbt build):
git remote add upstream [email protected]:plokhotnyuk/jsoniter-scala.git
git fetch --tags upstream
Prerequisites for building of Scala.js and Scala Native modules are Clang 18.x and Node.js 16.x. The following sequence of commands works for me:
sudo apt install clang libstdc++-12-dev libgc-dev
curl https://raw.githubusercontent.com/creationix/nvm/master/install.sh | bash
source ~/.bashrc
nvm install 16
node -v
Get report of available dependency updates
sbt ";dependencyUpdates; reload plugins; dependencyUpdates; reload return"
Run tests, check coverage and binary compatibility
sbt -java-home /usr/lib/jvm/jdk-11 ++2.13.15 clean coverage jsoniter-scala-coreJVM/test jsoniter-scala-circeJVM/test jsoniter-scala-macrosJVM/test jsoniter-scala-benchmarkJVM/test coverageReport
sbt -java-home /usr/lib/jvm/jdk-11 clean +test +mimaReportBinaryIssues
BEWARE: jsoniter-scala is included into Scala Community Build for Scala 2 and Scala Open Community Build for Scala 3.
Run JVM benchmarks
Before benchmark running check if your CPU works in performance
mode (not a powersave
one). On Linux use following
commands to print current and set the performance
mode:
cat /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor
for i in $(ls /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor); do echo performance | sudo tee $i; done
Then view your CPU frequency with:
cat /proc/cpuinfo | grep -i mhz
Stop un-needed applications and services. List of running services can be printed by:
sudo service --status-all | grep '\[ + \]'
sudo systemctl list-units --state running
Then clear cache memory to improve system performance. One way to clear cache memory on Linux without having to reboot the system:
sudo su
free -m -h && sync && echo 3 > /proc/sys/vm/drop_caches && free -m -h
Sbt plugin for JMH tool is used for benchmarking, to see all their features and options please check Sbt-JMH docs and JMH tool docs
Learn how to write benchmarks in JMH samples and JMH articles posted in Aleksey Shipilёv’s and Nitsan Wakart’s blogs.
List of available options can be printed by:
sbt jsoniter-scala-benchmarkJVM/clean 'jsoniter-scala-benchmarkJVM/jmh:run -h'
Results of benchmark can be stored in different formats: *.csv, *.json, etc. All supported formats can be listed by:
sbt jsoniter-scala-benchmarkJVM/clean 'jsoniter-scala-benchmarkJVM/jmh:run -lrf'
JMH allows running benchmarks with different profilers, to get a list of supported use (can require entering of user password):
sbt jsoniter-scala-benchmarkJVM/clean 'jsoniter-scala-benchmarkJVM/jmh:run -lprof'
Help for profiler options can be printed by following command (<profiler_name>
should be replaced by the name of the
supported profiler from the command above):
sbt jsoniter-scala-benchmarkJVM/clean 'jsoniter-scala-benchmarkJVM/jmh:run -prof <profiler_name>:help'
For parametrized benchmarks the constant value(s) for parameter(s) can be set by -p
option:
sbt jsoniter-scala-benchmarkJVM/clean 'jsoniter-scala-benchmarkJVM/jmh:run -p size=1,10,100,1000 ArrayOf.*'
To see throughput with the allocation rate of generated codecs run benchmarks with GC profiler using the following command:
sbt jsoniter-scala-benchmarkJVM/clean 'jsoniter-scala-benchmarkJVM/jmh:run -prof gc .*Reading.*'
Results that are stored in JSON can be easy plotted in JMH Visualizer by drugging & dropping
of your file to the drop zone or using the source
parameter with an HTTP link to your file in the URL like
here.
On Linux the perf profiler can be used to see CPU event statistics normalized per ops:
sbt jsoniter-scala-benchmarkJVM/clean 'jsoniter-scala-benchmarkJVM/jmh:run -prof perfnorm TwitterAPIReading.jsoniterScala'
Also, it can be run with a specified list of events. Here is an example of benchmarking using 16 threads to check of CPU stalls:
sbt jsoniter-scala-benchmarkJVM/clean 'jsoniter-scala-benchmarkJVM/jmh:run -t 16 -prof "perfnorm:event=cycles,instructions,uops_executed.core,uops_executed.stall_cycles,cache-references,cache-misses,cycle_activity.stalls_total,cycle_activity.stalls_mem_any,cycle_activity.stalls_l3_miss,cycle_activity.stalls_l2_miss,cycle_activity.stalls_l1d_miss" .*'
List of available events for the perf profiler can be retrieved by the following command:
perf list
To get a result for some benchmarks with an in-flight recording file from JFR profiler use command like this:
sbt jsoniter-scala-benchmarkJVM/clean 'jsoniter-scala-benchmarkJVM/jmh:run -prof "jfr:dir=target/jfr-reports" -wi 10 -i 60 TwitterAPIReading.jsoniterScala'
You will get the profile in the jsoniter-scala-benchmark/jvm/target/jfr-reports
directory.
To run benchmarks with recordings by Async profiler, extract
binaries to /opt/async-profiler
directory and set the following runtime variables to capture kernel frames:
sudo sysctl kernel.perf_event_paranoid=1
sudo sysctl kernel.kptr_restrict=0
Then use command like this:
sbt -java-home /usr/lib/jvm/jdk-21 jsoniter-scala-benchmarkJVM/clean 'jsoniter-scala-benchmarkJVM/jmh:run -prof "async:dir=target/async-reports;interval=1000000;output=flamegraph;libPath=/opt/async-profiler/lib/libasyncProfiler.so" -jvmArgsAppend "-XX:+UnlockDiagnosticVMOptions -XX:+DebugNonSafepoints" --p size=128 -wi 5 -i 10 jsoniterScala'
Now you can open direct and reverse flame graphs in the jsoniter-scala-benchmark/jvmtarget/async-reports
directory.
Beware that -XX:+DebugNonSafepoints
can lead to incorrect report due to a bug which was fixed only for JDK 21 currently.
To see list of available events need to start your app or benchmark, and run jps
command. I will show list of PIDs and
names for currently running Java processes. While your Java process still running launch the Async Profiler with the
list
option and ID of your process like here:
$ ~/Projects/com/github/jvm-profiling-tools/async-profiler/profiler.sh list 6924
Basic events:
cpu
alloc
lock
wall
itimer
Perf events:
page-faults
context-switches
cycles
instructions
cache-references
cache-misses
branches
branch-misses
bus-cycles
L1-dcache-load-misses
LLC-load-misses
dTLB-load-misses
mem:breakpoint
trace:tracepoint
Following command can be used to profile and print assembly code of the hottest methods, but it requires a setup of
hsdis
library to make PrintAssembly feature enabled:
sbt jsoniter-scala-benchmarkJVM/clean 'jsoniter-scala-benchmarkJVM/jmh:run -prof perfasm -wi 10 -i 10 -p size=128 BigIntReading.jsoniterScala'
More info about extras, options, and ability to generate flame graphs see in Sbt-JMH docs
Other benchmarks with results for jsoniter-scala:
- comparison with other JSON parsers for different programming languages and compilers
- comparison with most performant java parsers: simdjson-java, fastjson, jackson, etc.
- comparison with other JSON parsers for Scala mostly on samples from real APIs, but with mapping to simple types only like strings and primitives and results for GraalVM EE Java8 only
- comparison with the best binary parsers and serializers for Scala
- comparison with different binary and text serializers for Scala
- comparison with JSON serializers for Scala on synthetic samples
- comparison with JSON parsers for Scala when parsing from/to a string representation
- comparison with a state-of-the-art filter that by "building structural indices converts control flow into data flow, thereby largely eliminating inherently unpredictable branches in the program and exploiting the parallelism available in modern processors"
Run Scala.js benchmarks
Use JDK 11+ for building of jsoniter-scala-benchmarkJS
module for Scala 2.13 and Scala 3:
sbt -DassemblyJSBenchmarks -java-home /usr/lib/jvm/jdk-11 +jsoniter-scala-benchmarkJS/fullOptJS
Then open the list of benchmarks in a browser:
cd jsoniter-scala-benchmark/js
open scala-3-fullopt.html
open scala-2.13-fullopt.html
Then select the batch mode with storing results in a .zip
file.
Use the following command for merging unpacked results from browsers: jq -s '[.[][]]' firefox/*.json >firefox.json
The released version of Scala.js benchmarks is available here.
Run compilation time benchmarks
Use the circe-argonaut-compile-times project to compare compilation time of jsoniter-scala for deeply nested product types with other JSON parsers like argonaut, play-json, and circe in 3 modes: auto, semi-auto, and derivation.
For Scala 3 use the scala3-compile-tests project to compare compilation time of jsoniter-scala for Scala 3 enumerations (sum types) with circe in semi-auto mode.
Publish locally
Use publishing of SNAPSHOT versions to your local artifact repositories for testing with other libraries or applications.
Publish to the local Ivy repo:
sbt clean +publishLocal
Publish to the local Maven repo:
sbt clean +publishM2
Releasehttps://github.com/softwaremill/bootzook
For version numbering use Recommended Versioning Scheme that is used in the Scala ecosystem.
Double-check binary and source compatibility, including behavior, and release using the following command on the environment with 16+GB of RAM:
sbt -java-home /usr/lib/jvm/jdk-11 -J-Xmx12g clean release
Do not push changes to GitHub until promoted artifacts for the new version are not available for downloading on Maven Central Repository to avoid binary compatibility check failures in triggered Travis CI builds.
The last step is updating of the tag info in a release list.
More Resourcesto explore the angular.
mail [email protected] to add your project or resources here 🔥.
- 1A toolkit for servicing HTTP requests in Scala
https://github.com/unfiltered/unfiltered
A toolkit for servicing HTTP requests in Scala. Contribute to unfiltered/unfiltered development by creating an account on GitHub.
- 2A Scala DSL for talking with databases with minimum verbosity and maximum type safety
https://github.com/squeryl/squeryl
A Scala DSL for talking with databases with minimum verbosity and maximum type safety - squeryl/squeryl
- 3Apache Flink
https://github.com/apache/flink
Apache Flink. Contribute to apache/flink development by creating an account on GitHub.
- 4Vert.x for Scala
https://github.com/vert-x3/vertx-lang-scala
Vert.x for Scala. Contribute to vert-x3/vertx-lang-scala development by creating an account on GitHub.
- 5Chromaprint/AcoustID audio fingerprinting for the JVM
https://github.com/mgdigital/Chromaprint.scala
Chromaprint/AcoustID audio fingerprinting for the JVM - mgdigital/Chromaprint.scala
- 6A macro library that converts native imperative syntax to scalaz's monadic expressions
https://github.com/ThoughtWorksInc/each
A macro library that converts native imperative syntax to scalaz's monadic expressions - ThoughtWorksInc/each
- 7Incredibly simple DI Scala library.
https://github.com/yakivy/jam
Incredibly simple DI Scala library. Contribute to yakivy/jam development by creating an account on GitHub.
- 8Security library for Play framework 2 in Java and Scala: OAuth, CAS, SAML, OpenID Connect, LDAP, JWT...
https://github.com/pac4j/play-pac4j
Security library for Play framework 2 in Java and Scala: OAuth, CAS, SAML, OpenID Connect, LDAP, JWT... - pac4j/play-pac4j
- 9laserdisc-io/mysql-binlog-stream
https://github.com/laserdisc-io/mysql-binlog-stream
Contribute to laserdisc-io/mysql-binlog-stream development by creating an account on GitHub.
- 10GNU Gettext .po file loader for Scala
https://github.com/xitrum-framework/scaposer
GNU Gettext .po file loader for Scala. Contribute to xitrum-framework/scaposer development by creating an account on GitHub.
- 11Light-weight convenience wrapper around Lucene to simplify complex tasks and add Scala sugar.
https://github.com/outr/lucene4s
Light-weight convenience wrapper around Lucene to simplify complex tasks and add Scala sugar. - outr/lucene4s
- 12Workflow engine for exploration of simulation models using high throughput computing
https://github.com/openmole/openmole
Workflow engine for exploration of simulation models using high throughput computing - openmole/openmole
- 13PostgreSQL protocol support for Finagle
https://github.com/finagle/finagle-postgres
PostgreSQL protocol support for Finagle. Contribute to finagle/finagle-postgres development by creating an account on GitHub.
- 14Simple play module for authenticating against Google
https://github.com/guardian/play-googleauth
Simple play module for authenticating against Google - guardian/play-googleauth
- 15Extensible JOSE library for Scala
https://github.com/blackdoor/jose
Extensible JOSE library for Scala. Contribute to blackdoor/jose development by creating an account on GitHub.
- 16Large off-heap arrays and mmap files for Scala and Java
https://github.com/xerial/larray
Large off-heap arrays and mmap files for Scala and Java - xerial/larray
- 17A scala library for connecting to a redis server, or a cluster of redis nodes using consistent hashing on the client side.
https://github.com/debasishg/scala-redis
A scala library for connecting to a redis server, or a cluster of redis nodes using consistent hashing on the client side. - debasishg/scala-redis
- 18Idiomatic, typesafe, and reactive Scala client for Apache Pulsar
https://github.com/CleverCloud/pulsar4s
Idiomatic, typesafe, and reactive Scala client for Apache Pulsar - CleverCloud/pulsar4s
- 19Purely functional JSON parser and library in scala.
https://github.com/argonaut-io/argonaut
Purely functional JSON parser and library in scala. - argonaut-io/argonaut
- 20Modern Load Testing as Code
https://github.com/gatling/gatling
Modern Load Testing as Code. Contribute to gatling/gatling development by creating an account on GitHub.
- 21A Scala ORM library
https://github.com/kostaskougios/mapperdao
A Scala ORM library. Contribute to kostaskougios/mapperdao development by creating an account on GitHub.
- 22Docker containers for testing in scala
https://github.com/testcontainers/testcontainers-scala
Docker containers for testing in scala. Contribute to testcontainers/testcontainers-scala development by creating an account on GitHub.
- 23A scala diff/patch library for Json
https://github.com/gnieh/diffson
A scala diff/patch library for Json. Contribute to gnieh/diffson development by creating an account on GitHub.
- 24Testing tool in Scala for HTTP JSON API
https://github.com/agourlay/cornichon
Testing tool in Scala for HTTP JSON API. Contribute to agourlay/cornichon development by creating an account on GitHub.
- 25If you don't agree with the data
https://github.com/splink/veto
If you don't agree with the data. Contribute to splink/veto development by creating an account on GitHub.
- 26Software Specifications for Scala
https://github.com/etorreborre/specs2
Software Specifications for Scala. Contribute to etorreborre/specs2 development by creating an account on GitHub.
- 27The Couchbase Monorepo for JVM Clients: Java, Scala, io-core…
https://github.com/couchbase/couchbase-jvm-clients
The Couchbase Monorepo for JVM Clients: Java, Scala, io-core… - couchbase/couchbase-jvm-clients
- 28Salat is a simple serialization library for case classes.
https://github.com/salat/salat
Salat is a simple serialization library for case classes. - salat/salat
- 29Practical effect composition library based on abstract wrapping type and the free monad
https://github.com/ISCPIF/freedsl
Practical effect composition library based on abstract wrapping type and the free monad - ISCPIF/freedsl
- 30SevenZip library for Scala, easy to use.
https://github.com/gonearewe/SevenZ4S
SevenZip library for Scala, easy to use. . Contribute to gonearewe/SevenZ4S development by creating an account on GitHub.
- 31The super light testing library for Scala and Scala.js
https://github.com/monix/minitest
The super light testing library for Scala and Scala.js - monix/minitest
- 32A module that provides OAuth, OAuth2 and OpenID authentication for Play Framework applications
https://github.com/jaliss/securesocial
A module that provides OAuth, OAuth2 and OpenID authentication for Play Framework applications - jaliss/securesocial
- 33Compile-time Language Integrated Queries for Scala
https://github.com/zio/zio-quill
Compile-time Language Integrated Queries for Scala - zio/zio-quill
- 34Scala Scripting
https://github.com/com-lihaoyi/Ammonite
Scala Scripting. Contribute to com-lihaoyi/Ammonite development by creating an account on GitHub.
- 35Slick (Scala Language Integrated Connection Kit) is a modern database query and access library for Scala
https://github.com/slick/slick
Slick (Scala Language Integrated Connection Kit) is a modern database query and access library for Scala - slick/slick
- 36Property-based testing for Scala
https://github.com/typelevel/scalacheck
Property-based testing for Scala. Contribute to typelevel/scalacheck development by creating an account on GitHub.
- 37Simpler DynamoDB access for Scala
https://github.com/scanamo/scanamo
Simpler DynamoDB access for Scala. Contribute to scanamo/scanamo development by creating an account on GitHub.
- 38Type-Safe framework for defining, modifying, and querying SQL databases
https://github.com/outr/scalarelational
Type-Safe framework for defining, modifying, and querying SQL databases - outr/scalarelational
- 39ScalaFX simplifies creation of JavaFX-based user interfaces in Scala
https://github.com/scalafx/scalafx
ScalaFX simplifies creation of JavaFX-based user interfaces in Scala - scalafx/scalafx
- 40Performant database access in Scala
https://github.com/lucidsoftware/relate
Performant database access in Scala. Contribute to lucidsoftware/relate development by creating an account on GitHub.
- 41Scala library for boilerplate-free validation
https://github.com/krzemin/octopus
Scala library for boilerplate-free validation. Contribute to krzemin/octopus development by creating an account on GitHub.
- 42Connect a Scala REPL to running JVM processes without any prior setup
https://github.com/xitrum-framework/scalive
Connect a Scala REPL to running JVM processes without any prior setup - xitrum-framework/scalive
- 43A ZIO-based redis client
https://github.com/zio/zio-redis
A ZIO-based redis client. Contribute to zio/zio-redis development by creating an account on GitHub.
- 44Tiny Scala high-performance, async web framework, inspired by Sinatra
https://github.com/scalatra/scalatra
Tiny Scala high-performance, async web framework, inspired by Sinatra - scalatra/scalatra
- 45Reactive data-binding for Scala
https://github.com/ThoughtWorksInc/Binding.scala
Reactive data-binding for Scala. Contribute to ThoughtWorksInc/Binding.scala development by creating an account on GitHub.
- 46The Anorm database library
https://github.com/playframework/anorm
The Anorm database library. Contribute to playframework/anorm development by creating an account on GitHub.
- 47A module for the Play Framework to build highly modular applications
https://github.com/splink/pagelets
A module for the Play Framework to build highly modular applications - splink/pagelets
- 48I/O and Microservice library for Scala
https://github.com/tumblr/colossus
I/O and Microservice library for Scala. Contribute to tumblr/colossus development by creating an account on GitHub.
- 49Scala library to sign HTTP requests to AWS services.
https://github.com/ticofab/aws-request-signer
Scala library to sign HTTP requests to AWS services. - ticofab/aws-request-signer
- 50Next generation user interface and application development in Scala and Scala.js for web, mobile, and desktop.
https://github.com/outr/youi
Next generation user interface and application development in Scala and Scala.js for web, mobile, and desktop. - outr/youi
- 51Statistical Machine Intelligence & Learning Engine
https://github.com/haifengl/smile
Statistical Machine Intelligence & Learning Engine - haifengl/smile
- 52Microbenchmarking and performance regression testing framework for the JVM platform.
https://github.com/scalameter/scalameter
Microbenchmarking and performance regression testing framework for the JVM platform. - scalameter/scalameter
- 53A testing tool for Scala and Java developers
https://github.com/scalatest/scalatest
A testing tool for Scala and Java developers. Contribute to scalatest/scalatest development by creating an account on GitHub.
- 54:monorail: "Scala on Rails" - A full-stack web app framework for rapid development in Scala
https://github.com/skinny-framework/skinny-framework
:monorail: "Scala on Rails" - A full-stack web app framework for rapid development in Scala - skinny-framework/skinny-framework
- 55Molecule translates custom Scala code to database queries for multiple databases.
https://github.com/scalamolecule/molecule
Molecule translates custom Scala code to database queries for multiple databases. - scalamolecule/molecule
- 56Cryptographic primitives for Scala
https://github.com/input-output-hk/scrypto
Cryptographic primitives for Scala. Contribute to input-output-hk/scrypto development by creating an account on GitHub.
- 57A lightweight framework for writing REST services in Scala.
https://github.com/mesosphere/chaos
A lightweight framework for writing REST services in Scala. - mesosphere/chaos
- 58Async and clustered Scala web framework and HTTP(S) server
https://github.com/xitrum-framework/xitrum
Async and clustered Scala web framework and HTTP(S) server - xitrum-framework/xitrum
- 59A distributed tracing extension for Akka. Provides integration with Play framework, Spray and Akka HTTP.
https://github.com/levkhomich/akka-tracing
A distributed tracing extension for Akka. Provides integration with Play framework, Spray and Akka HTTP. - levkhomich/akka-tracing
- 60A simple FRP library and a web UI framework built on it
https://github.com/nafg/reactive
A simple FRP library and a web UI framework built on it - nafg/reactive
- 61Facebook's React on Scala.JS
https://github.com/japgolly/scalajs-react
Facebook's React on Scala.JS. Contribute to japgolly/scalajs-react development by creating an account on GitHub.
- 62Figaro Programming Language and Core Libraries
https://github.com/charles-river-analytics/figaro
Figaro Programming Language and Core Libraries. Contribute to charles-river-analytics/figaro development by creating an account on GitHub.
- 63Optimus is a mathematical programming library for Scala.
https://github.com/vagmcs/Optimus
Optimus is a mathematical programming library for Scala. - vagmcs/Optimus
- 64Fast JSON parser/generator for Scala
https://github.com/gzoller/ScalaJack
Fast JSON parser/generator for Scala. Contribute to gzoller/ScalaJack development by creating an account on GitHub.
- 65Apache Spark - A unified analytics engine for large-scale data processing
https://github.com/apache/spark
Apache Spark - A unified analytics engine for large-scale data processing - apache/spark
- 66scala SQL api
https://github.com/wangzaixiang/scala-sql
scala SQL api. Contribute to wangzaixiang/scala-sql development by creating an account on GitHub.
- 67Scala support library for integrating the JSON API spec with Spray, Play! or Circe
https://github.com/scala-jsonapi/scala-jsonapi
Scala support library for integrating the JSON API spec with Spray, Play! or Circe - scala-jsonapi/scala-jsonapi
- 68Scala code generator for Avro schemas.
https://github.com/malcolmgreaves/avro-codegen
Scala code generator for Avro schemas. Contribute to malcolmgreaves/avro-codegen development by creating an account on GitHub.
- 69Protocol buffer compiler for Scala.
https://github.com/scalapb/ScalaPB
Protocol buffer compiler for Scala. Contribute to scalapb/ScalaPB development by creating an account on GitHub.
- 70Functional JDBC layer for Scala.
https://github.com/tpolecat/doobie
Functional JDBC layer for Scala. Contribute to tpolecat/doobie development by creating an account on GitHub.
- 71CPU and GPU-accelerated Machine Learning Library
https://github.com/BIDData/BIDMach
CPU and GPU-accelerated Machine Learning Library. Contribute to BIDData/BIDMach development by creating an account on GitHub.
- 72Graph for Scala is intended to provide basic graph functionality seamlessly fitting into the Scala Collection Library. Like the well known members of scala.collection, Graph for Scala is an in-memory graph library aiming at editing and traversing graphs, finding cycles etc. in a user-friendly way.
https://github.com/scala-graph/scala-graph
Graph for Scala is intended to provide basic graph functionality seamlessly fitting into the Scala Collection Library. Like the well known members of scala.collection, Graph for Scala is an in-memo...
- 73Axle Domain Specific Language for Scientific Cloud Computing and Visualization
https://github.com/axlelang/axle
Axle Domain Specific Language for Scientific Cloud Computing and Visualization - axlelang/axle
- 74Lightweight and fast serialization library for Scala 2/3 based on Protocol Buffers with macros
https://github.com/zero-deps/proto
Lightweight and fast serialization library for Scala 2/3 based on Protocol Buffers with macros - zero-deps/proto
- 75Scala Uniquely Bound Classes Under Traits
https://github.com/dickwall/subcut
Scala Uniquely Bound Classes Under Traits. Contribute to dickwall/subcut development by creating an account on GitHub.
- 76Highly available distributed strong eventual consistent and sequentially consistent storage with feeds, sorting and search
https://github.com/zero-deps/kvs
Highly available distributed strong eventual consistent and sequentially consistent storage with feeds, sorting and search - zero-deps/kvs
- 77Single Page Applications running on the server side.
https://github.com/fomkin/korolev
Single Page Applications running on the server side. - fomkin/korolev
- 78A foundational framework for distributed programming.
https://github.com/reactors-io/reactors
A foundational framework for distributed programming. - reactors-io/reactors
- 79A dimensional analysis library based on dependent types
https://github.com/to-ithaca/libra
A dimensional analysis library based on dependent types - to-ithaca/libra
- 80CSV handling library for Scala
https://github.com/nrinaudo/kantan.csv
CSV handling library for Scala. Contribute to nrinaudo/kantan.csv development by creating an account on GitHub.
- 81MessagePack serializer implementation for Scala / msgpack.org[Scala]
https://github.com/msgpack/msgpack-scala
MessagePack serializer implementation for Scala / msgpack.org[Scala] - msgpack/msgpack-scala
- 82uPickle: a simple, fast, dependency-free JSON & Binary (MessagePack) serialization library for Scala
https://github.com/com-lihaoyi/upickle
uPickle: a simple, fast, dependency-free JSON & Binary (MessagePack) serialization library for Scala - com-lihaoyi/upickle
- 83a simple Scala CLI parsing library
https://github.com/scallop/scallop
a simple Scala CLI parsing library. Contribute to scallop/scallop development by creating an account on GitHub.
- 84Add-on module for Jackson (https://github.com/FasterXML/jackson) to support Scala-specific datatypes
https://github.com/FasterXML/jackson-module-scala
Add-on module for Jackson (https://github.com/FasterXML/jackson) to support Scala-specific datatypes - FasterXML/jackson-module-scala
- 85Type-safe data migration tool for Slick, Git and beyond.
https://github.com/lastland/scala-forklift
Type-safe data migration tool for Slick, Git and beyond. - lastland/scala-forklift
- 86A tidy SQL-based DB access library for Scala developers. This library naturally wraps JDBC APIs and provides you easy-to-use APIs.
https://github.com/scalikejdbc/scalikejdbc
A tidy SQL-based DB access library for Scala developers. This library naturally wraps JDBC APIs and provides you easy-to-use APIs. - scalikejdbc/scalikejdbc
- 87Scala compiler plugin that acts like GNU xgettext command to extract i18n strings in Scala source code files to Gettext .po file
https://github.com/xitrum-framework/scala-xgettext
Scala compiler plugin that acts like GNU xgettext command to extract i18n strings in Scala source code files to Gettext .po file - xitrum-framework/scala-xgettext
- 88REScala - distributed and reactive programming embedded in OO and FP programs.
https://github.com/rescala-lang/REScala
REScala - distributed and reactive programming embedded in OO and FP programs. - rescala-lang/REScala
- 89Scala classpath scanner
https://github.com/xitrum-framework/sclasner
Scala classpath scanner. Contribute to xitrum-framework/sclasner development by creating an account on GitHub.
- 90Iteratees for Cats
https://github.com/travisbrown/iteratee
Iteratees for Cats. Contribute to travisbrown/iteratee development by creating an account on GitHub.
- 91Fast, secure JSON library with tight ZIO integration.
https://github.com/zio/zio-json
Fast, secure JSON library with tight ZIO integration. - zio/zio-json
- 92Schema registry for CSV, TSV, JSON, AVRO and Parquet schema. Supports schema inference and GraphQL API.
https://github.com/indix/schemer
Schema registry for CSV, TSV, JSON, AVRO and Parquet schema. Supports schema inference and GraphQL API. - indix/schemer
- 93Play2.x Authentication and Authorization module
https://github.com/t2v/play2-auth
Play2.x Authentication and Authorization module. Contribute to t2v/play2-auth development by creating an account on GitHub.
- 94Jawn is for parsing jay-sawn (JSON)
https://github.com/typelevel/jawn
Jawn is for parsing jay-sawn (JSON). Contribute to typelevel/jawn development by creating an account on GitHub.
- 95An ONNX (Open Neural Network eXchange) API and backend for typeful, functional deep learning and classical machine learning in Scala 3
https://github.com/EmergentOrder/onnx-scala
An ONNX (Open Neural Network eXchange) API and backend for typeful, functional deep learning and classical machine learning in Scala 3 - EmergentOrder/onnx-scala
- 96Labeled records for Scala based on structural refinement types and macros.
https://github.com/scala-records/scala-records
Labeled records for Scala based on structural refinement types and macros. - scala-records/scala-records
- 97Breeze is a numerical processing library for Scala.
https://github.com/scalanlp/breeze
Breeze is a numerical processing library for Scala. - scalanlp/breeze
- 98Scala Library for Reading Flat File Data (CSV/TSV/XLS/XLSX)
https://github.com/frugalmechanic/fm-flatfile
Scala Library for Reading Flat File Data (CSV/TSV/XLS/XLSX) - frugalmechanic/fm-flatfile
- 99Platform to build distributed, scalable, enterprise-wide business applications
https://github.com/annetteplatform/annette
Platform to build distributed, scalable, enterprise-wide business applications - annetteplatform/annette
- 100Cassovary is a simple big graph processing library for the JVM
https://github.com/twitter/cassovary
Cassovary is a simple big graph processing library for the JVM - twitter/cassovary
- 101A concurrent reactive programming framework.
https://github.com/storm-enroute/reactors
A concurrent reactive programming framework. Contribute to storm-enroute/reactors development by creating an account on GitHub.
- 102Library to register and lookup actors by names in an Akka cluster
https://github.com/xitrum-framework/glokka
Library to register and lookup actors by names in an Akka cluster - xitrum-framework/glokka
- 103:cake: doddle-model: machine learning in Scala.
https://github.com/picnicml/doddle-model
:cake: doddle-model: machine learning in Scala. Contribute to picnicml/doddle-model development by creating an account on GitHub.
- 104A Scala API for Apache Beam and Google Cloud Dataflow.
https://github.com/spotify/scio
A Scala API for Apache Beam and Google Cloud Dataflow. - spotify/scio
- 105A mini Scala utility library
https://github.com/scala-hamsters/hamsters
A mini Scala utility library. Contribute to scala-hamsters/hamsters development by creating an account on GitHub.
- 106Powerful new number types and numeric abstractions for Scala.
https://github.com/typelevel/spire
Powerful new number types and numeric abstractions for Scala. - typelevel/spire
- 107A Persistence Framework for Scala and NoSQL
https://github.com/longevityframework/longevity
A Persistence Framework for Scala and NoSQL. Contribute to longevityframework/longevity development by creating an account on GitHub.
- 108Async lightweight Scala web framework
https://github.com/dvarelap/peregrine
Async lightweight Scala web framework. Contribute to dvarelap/peregrine development by creating an account on GitHub.
- 109CSV Reader/Writer for Scala
https://github.com/tototoshi/scala-csv
CSV Reader/Writer for Scala. Contribute to tototoshi/scala-csv development by creating an account on GitHub.
- 110A Thrift parser/generator
https://github.com/twitter/scrooge
A Thrift parser/generator. Contribute to twitter/scrooge development by creating an account on GitHub.
- 111N-dimensional / multi-dimensional arrays (tensors) in Scala 3. Think NumPy ndarray / PyTorch Tensor but type-safe over shapes, array/axis labels & numeric data types
https://github.com/SciScala/NDScala
N-dimensional / multi-dimensional arrays (tensors) in Scala 3. Think NumPy ndarray / PyTorch Tensor but type-safe over shapes, array/axis labels & numeric data types - SciScala/NDScala
- 112A JSR-310 port of nscala_time
https://github.com/chronoscala/chronoscala
A JSR-310 port of nscala_time. Contribute to chronoscala/chronoscala development by creating an account on GitHub.
- 113Lightweight Scala Dependency Injection Library
https://github.com/scaldi/scaldi
Lightweight Scala Dependency Injection Library. Contribute to scaldi/scaldi development by creating an account on GitHub.
- 114A fault tolerant, protocol-agnostic RPC system
https://github.com/twitter/finagle
A fault tolerant, protocol-agnostic RPC system. Contribute to twitter/finagle development by creating an account on GitHub.
- 115Scala library for accessing various file, batch systems, job schedulers and grid middlewares.
https://github.com/openmole/gridscale
Scala library for accessing various file, batch systems, job schedulers and grid middlewares. - openmole/gridscale
- 116JVM - Java, Kotlin, Scala image processing library
https://github.com/sksamuel/scrimage
JVM - Java, Kotlin, Scala image processing library - sksamuel/scrimage
- 117A group of neural-network libraries for functional and mainstream languages
https://github.com/mrdimosthenis/Synapses
A group of neural-network libraries for functional and mainstream languages - mrdimosthenis/Synapses
- 118Alpakka Kafka connector - Alpakka is a Reactive Enterprise Integration library for Java and Scala, based on Reactive Streams and Akka.
https://github.com/akka/alpakka-kafka
Alpakka Kafka connector - Alpakka is a Reactive Enterprise Integration library for Java and Scala, based on Reactive Streams and Akka. - akka/alpakka-kafka
- 119Productivity-oriented collection of lightweight fancy stuff for Scala toolchain
https://github.com/7mind/izumi
Productivity-oriented collection of lightweight fancy stuff for Scala toolchain - 7mind/izumi
- 120Real Time Analytics and Data Pipelines based on Spark Streaming
https://github.com/Stratio/sparta
Real Time Analytics and Data Pipelines based on Spark Streaming - Stratio/sparta
- 121C4E, a JVM friendly library written in Scala for both local and distributed (Spark) Clustering.
https://github.com/Clustering4Ever/Clustering4Ever
C4E, a JVM friendly library written in Scala for both local and distributed (Spark) Clustering. - Clustering4Ever/Clustering4Ever
- 122Scala extensions for Google Guice
https://github.com/codingwell/scala-guice
Scala extensions for Google Guice. Contribute to codingwell/scala-guice development by creating an account on GitHub.
- 123Purely functional genetic algorithms for multi-objective optimisation
https://github.com/openmole/mgo
Purely functional genetic algorithms for multi-objective optimisation - openmole/mgo
- 124A composable command-line parser for Scala.
https://github.com/bkirwi/decline
A composable command-line parser for Scala. Contribute to bkirwi/decline development by creating an account on GitHub.
- 125ABANDONED Pure Scala serialization library with annotations
https://github.com/fomkin/pushka
ABANDONED Pure Scala serialization library with annotations - fomkin/pushka
- 126Modify deeply nested case class fields
https://github.com/softwaremill/quicklens
Modify deeply nested case class fields. Contribute to softwaremill/quicklens development by creating an account on GitHub.
- 127Non-blocking, ultra-fast Scala Redis client built on top of Akka IO, used in production at Livestream
https://github.com/Livestream/scredis
Non-blocking, ultra-fast Scala Redis client built on top of Akka IO, used in production at Livestream - Livestream/scredis
- 128RxScala – Reactive Extensions for Scala – a library for composing asynchronous and event-based programs using observable sequences
https://github.com/ReactiveX/RxScala
RxScala – Reactive Extensions for Scala – a library for composing asynchronous and event-based programs using observable sequences - ReactiveX/RxScala
- 129Asynchronous, Reactive Programming for Scala and Scala.js.
https://github.com/monix/monix
Asynchronous, Reactive Programming for Scala and Scala.js. - monix/monix
- 130Easy way to create Free Monad using Scala macros with first-class Intellij support.
https://github.com/Thangiee/Freasy-Monad
Easy way to create Free Monad using Scala macros with first-class Intellij support. - Thangiee/Freasy-Monad
- 131Eff monad for cats - https://atnos-org.github.io/eff
https://github.com/atnos-org/eff
Eff monad for cats - https://atnos-org.github.io/eff - atnos-org/eff
- 132The missing MatPlotLib for Scala + Spark
https://github.com/vegas-viz/Vegas
The missing MatPlotLib for Scala + Spark. Contribute to vegas-viz/Vegas development by creating an account on GitHub.
- 133Scala extensions for the Kryo serialization library
https://github.com/twitter/chill
Scala extensions for the Kryo serialization library - twitter/chill
- 134Minimal, type-safe RPC Scala library.
https://github.com/yakivy/poppet
Minimal, type-safe RPC Scala library. Contribute to yakivy/poppet development by creating an account on GitHub.
- 135Reactive Microservices for the JVM
https://github.com/lagom/lagom
Reactive Microservices for the JVM. Contribute to lagom/lagom development by creating an account on GitHub.
- 136A scala extension for Project Reactor's Flux and Mono
https://github.com/spring-attic/reactor-scala-extensions
A scala extension for Project Reactor's Flux and Mono - spring-attic/reactor-scala-extensions
- 137Scala testing library with actionable errors and extensible APIs
https://github.com/scalameta/munit
Scala testing library with actionable errors and extensible APIs - scalameta/munit
- 138Scala wrapper for SnakeYAML
https://github.com/jcazevedo/moultingyaml
Scala wrapper for SnakeYAML. Contribute to jcazevedo/moultingyaml development by creating an account on GitHub.
- 139SynapseGrid is a framework for constructing dynamic low latency data flow systems.
https://github.com/Primetalk/SynapseGrid
SynapseGrid is a framework for constructing dynamic low latency data flow systems. - Primetalk/SynapseGrid
- 140Distributed NoSQL Database
https://github.com/stephenmcd/curiodb
Distributed NoSQL Database. Contribute to stephenmcd/curiodb development by creating an account on GitHub.
- 141Abstract Algebra for Scala
https://github.com/twitter/algebird
Abstract Algebra for Scala. Contribute to twitter/algebird development by creating an account on GitHub.
- 142Spark package to "plug" holes in data using SQL based rules ⚡️ 🔌
https://github.com/indix/sparkplug
Spark package to "plug" holes in data using SQL based rules ⚡️ 🔌 - GitHub - indix/sparkplug: Spark package to "plug" holes in data using SQL based rules ⚡️ 🔌
- 143A simple testing framework for Scala
https://github.com/com-lihaoyi/utest
A simple testing framework for Scala. Contribute to com-lihaoyi/utest development by creating an account on GitHub.
- 144Scalable Image Analysis and Shape Modelling
https://github.com/unibas-gravis/scalismo
Scalable Image Analysis and Shape Modelling. Contribute to unibas-gravis/scalismo development by creating an account on GitHub.
- 145Web-based notebook that enables data-driven, interactive data analytics and collaborative documents with SQL, Scala and more.
https://github.com/apache/zeppelin
Web-based notebook that enables data-driven, interactive data analytics and collaborative documents with SQL, Scala and more. - apache/zeppelin
- 146Mutation testing for Scala
https://github.com/stryker-mutator/stryker4s
Mutation testing for Scala. Contribute to stryker-mutator/stryker4s development by creating an account on GitHub.
- 147Streaming MapReduce with Scalding and Storm
https://github.com/twitter/summingbird
Streaming MapReduce with Scalding and Storm. Contribute to twitter/summingbird development by creating an account on GitHub.
- 148A library that toggles Scala code at compile-time, like #if in C/C++
https://github.com/ThoughtWorksInc/enableIf.scala
A library that toggles Scala code at compile-time, like #if in C/C++ - ThoughtWorksInc/enableIf.scala
- 149Casbah is now officially end-of-life (EOL).
https://github.com/mongodb/casbah
Casbah is now officially end-of-life (EOL). Contribute to mongodb/casbah development by creating an account on GitHub.
- 150Build highly concurrent, distributed, and resilient message-driven applications on the JVM
https://github.com/akka/akka
Build highly concurrent, distributed, and resilient message-driven applications on the JVM - akka/akka
- 151A framework to create embedded Domain-Specific Languages in Scala
https://github.com/ThoughtWorksInc/Dsl.scala
A framework to create embedded Domain-Specific Languages in Scala - ThoughtWorksInc/Dsl.scala
- 152Scala library for boilerplate-free, type-safe data transformations
https://github.com/scalalandio/chimney
Scala library for boilerplate-free, type-safe data transformations - scalalandio/chimney
- 153Interactive and Reactive Data Science using Scala and Spark.
https://github.com/spark-notebook/spark-notebook
Interactive and Reactive Data Science using Scala and Spark. - spark-notebook/spark-notebook
- 154TensorFlow API for the Scala Programming Language
https://github.com/eaplatanios/tensorflow_scala
TensorFlow API for the Scala Programming Language. Contribute to eaplatanios/tensorflow_scala development by creating an account on GitHub.
- 155numsca is numpy for scala
https://github.com/botkop/numsca
numsca is numpy for scala. Contribute to botkop/numsca development by creating an account on GitHub.
- 156A cohesive & pragmatic framework of FP centric Scala libraries
https://github.com/frees-io/freestyle
A cohesive & pragmatic framework of FP centric Scala libraries - frees-io/freestyle
- 157Build software better, together
https://github.com/Sciss/ScalaCollider
GitHub is where people build software. More than 100 million people use GitHub to discover, fork, and contribute to over 420 million projects.
- 158A lightweight, clean and simple JSON implementation in Scala
https://github.com/spray/spray-json
A lightweight, clean and simple JSON implementation in Scala - spray/spray-json
- 159A new Scala wrapper for Joda Time based on scala-time
https://github.com/nscala-time/nscala-time
A new Scala wrapper for Joda Time based on scala-time - nscala-time/nscala-time
- 160Convenient and performant logging library for Scala wrapping SLF4J.
https://github.com/lightbend-labs/scala-logging
Convenient and performant logging library for Scala wrapping SLF4J. - lightbend-labs/scala-logging
- 161Blindsight is a Scala logging API with DSL based structured logging, fluent logging, semantic logging, flow logging, and context aware logging.
https://github.com/tersesystems/blindsight
Blindsight is a Scala logging API with DSL based structured logging, fluent logging, semantic logging, flow logging, and context aware logging. - tersesystems/blindsight
- 162Command Line Interface Scala Toolkit
https://github.com/backuity/clist
Command Line Interface Scala Toolkit. Contribute to backuity/clist development by creating an account on GitHub.
- 163command line options parsing for Scala
https://github.com/scopt/scopt
command line options parsing for Scala. Contribute to scopt/scopt development by creating an account on GitHub.
- 164Schema safe, type-safe, reactive Scala driver for Cassandra/Datastax Enterprise
https://github.com/outworkers/phantom
Schema safe, type-safe, reactive Scala driver for Cassandra/Datastax Enterprise - outworkers/phantom
- 165A Scala API for Cascading
https://github.com/twitter/scalding
A Scala API for Cascading. Contribute to twitter/scalding development by creating an account on GitHub.
- 166The fastest logging library in the world. Built from scratch in Scala and programmatically configurable.
https://github.com/outr/scribe
The fastest logging library in the world. Built from scratch in Scala and programmatically configurable. - outr/scribe
- 167State of the Art Natural Language Processing
https://github.com/JohnSnowLabs/spark-nlp
State of the Art Natural Language Processing. Contribute to JohnSnowLabs/spark-nlp development by creating an account on GitHub.
- 168Essential Building Blocks for Scala
https://github.com/wvlet/airframe
Essential Building Blocks for Scala. Contribute to wvlet/airframe development by creating an account on GitHub.
- 169ZIO — A type-safe, composable library for async and concurrent programming in Scala
https://github.com/zio/zio
ZIO — A type-safe, composable library for async and concurrent programming in Scala - zio/zio
- 170Lightweight, modular, and extensible library for functional programming.
https://github.com/typelevel/cats
Lightweight, modular, and extensible library for functional programming. - typelevel/cats
- 171Scala validation library
https://github.com/jap-company/fields
Scala validation library. Contribute to jap-company/fields development by creating an account on GitHub.
- 172Cask: a Scala HTTP micro-framework
https://github.com/com-lihaoyi/cask
Cask: a Scala HTTP micro-framework. Contribute to com-lihaoyi/cask development by creating an account on GitHub.
- 173Slick extensions for PostgreSQL
https://github.com/tminglei/slick-pg
Slick extensions for PostgreSQL. Contribute to tminglei/slick-pg development by creating an account on GitHub.
- 174First class syntax support for type classes in Scala
https://github.com/typelevel/simulacrum
First class syntax support for type classes in Scala - typelevel/simulacrum
- 175Persist-Json, a Fast Json Parser Written in Scala
https://github.com/nestorpersist/json
Persist-Json, a Fast Json Parser Written in Scala. Contribute to nestorpersist/json development by creating an account on GitHub.
- 176Refinement types for Scala
https://github.com/fthomas/refined
Refinement types for Scala. Contribute to fthomas/refined development by creating an account on GitHub.
- 177Generic programming for Scala
https://github.com/milessabin/shapeless
Generic programming for Scala. Contribute to milessabin/shapeless development by creating an account on GitHub.
- 178Lift Framework
https://github.com/lift/framework
Lift Framework. Contribute to lift/framework development by creating an account on GitHub.
- 179Fast, testable, Scala services built on TwitterServer and Finagle
https://github.com/twitter/finatra
Fast, testable, Scala services built on TwitterServer and Finagle - twitter/finatra
- 180Build software better, together
https://github.com/wireapp/wire-signals
GitHub is where people build software. More than 100 million people use GitHub to discover, fork, and contribute to over 420 million projects.
- 181The Opinionated RabbitMQ Library for Scala and Akka
https://github.com/SpinGo/op-rabbit
The Opinionated RabbitMQ Library for Scala and Akka - SpinGo/op-rabbit
- 182JSON typeclasses that know the difference between null and absent fields
https://github.com/nrktkt/ninny-json
JSON typeclasses that know the difference between null and absent fields - nrktkt/ninny-json
- 183Scala macros for compile-time generation of safe and ultra-fast JSON codecs + circe booster
https://github.com/plokhotnyuk/jsoniter-scala
Scala macros for compile-time generation of safe and ultra-fast JSON codecs + circe booster - plokhotnyuk/jsoniter-scala
- 184LoMRF is an open-source implementation of Markov Logic Networks
https://github.com/anskarl/LoMRF
LoMRF is an open-source implementation of Markov Logic Networks - anskarl/LoMRF
- 185property based testing library for Scala
https://github.com/scalaprops/scalaprops
property based testing library for Scala. Contribute to scalaprops/scalaprops development by creating an account on GitHub.
- 186Yet another JSON library for Scala
https://github.com/circe/circe
Yet another JSON library for Scala. Contribute to circe/circe development by creating an account on GitHub.
- 187Native Scala mocking framework
https://github.com/paulbutcher/ScalaMock
Native Scala mocking framework. Contribute to paulbutcher/ScalaMock development by creating an account on GitHub.
- 188OAuth 2.0 server-side implementation written in Scala
https://github.com/nulab/scala-oauth2-provider
OAuth 2.0 server-side implementation written in Scala - nulab/scala-oauth2-provider
- 189A small, convenient, dependency-free library for command-line argument parsing in Scala
https://github.com/com-lihaoyi/mainargs
A small, convenient, dependency-free library for command-line argument parsing in Scala - com-lihaoyi/mainargs
- 190Scala + Druid: Scruid. A library that allows you to compose queries in Scala, and parse the result back into typesafe classes.
https://github.com/ing-bank/scruid
Scala + Druid: Scruid. A library that allows you to compose queries in Scala, and parse the result back into typesafe classes. - ing-bank/scruid
- 191akka-persistence-gcp-datastore is a journal and snapshot store plugin for akka-persistence using google cloud firestore in datastore mode.
https://github.com/innFactory/akka-persistence-gcp-datastore
akka-persistence-gcp-datastore is a journal and snapshot store plugin for akka-persistence using google cloud firestore in datastore mode. - GitHub - innFactory/akka-persistence-gcp-datastore: akk...
- 192Mirror of Apache Kafka
https://github.com/apache/kafka
Mirror of Apache Kafka. Contribute to apache/kafka development by creating an account on GitHub.
- 193:leaves: Non-blocking, Reactive MongoDB Driver for Scala
https://github.com/ReactiveMongo/ReactiveMongo
:leaves: Non-blocking, Reactive MongoDB Driver for Scala - ReactiveMongo/ReactiveMongo
- 194Scala GraphQL implementation
https://github.com/sangria-graphql/sangria
Scala GraphQL implementation. Contribute to sangria-graphql/sangria development by creating an account on GitHub.
- 195Functional, stream-based CSV processor for Scala
https://github.com/fingo/spata
Functional, stream-based CSV processor for Scala. Contribute to fingo/spata development by creating an account on GitHub.
- 196ActiveRecord-like ORM library for Scala
https://github.com/aselab/scala-activerecord
ActiveRecord-like ORM library for Scala. Contribute to aselab/scala-activerecord development by creating an account on GitHub.
- 197A Future-free Fs2 native pure FP Redis client
https://github.com/laserdisc-io/laserdisc
A Future-free Fs2 native pure FP Redis client. Contribute to laserdisc-io/laserdisc development by creating an account on GitHub.
- 198Scala framework for building beautiful and maintainable web applications.
https://github.com/UdashFramework/udash-core
Scala framework for building beautiful and maintainable web applications. - UdashFramework/udash-core
- 199Main Portal page for the Jackson project
https://github.com/FasterXML/jackson
Main Portal page for the Jackson project. Contribute to FasterXML/jackson development by creating an account on GitHub.
- 200Library to read, analyze, transform and generate Scala programs
https://github.com/scalameta/scalameta
Library to read, analyze, transform and generate Scala programs - scalameta/scalameta
- 201Compositional, streaming I/O library for Scala
https://github.com/typelevel/fs2
Compositional, streaming I/O library for Scala. Contribute to typelevel/fs2 development by creating an account on GitHub.
- 202The Community Maintained High Velocity Web Framework For Java and Scala.
https://github.com/playframework/playframework
The Community Maintained High Velocity Web Framework For Java and Scala. - playframework/playframework
- 203Scala lightweight, type-safe, asynchronous driver for neo4j
https://github.com/neotypes/neotypes
Scala lightweight, type-safe, asynchronous driver for neo4j - GitHub - neotypes/neotypes: Scala lightweight, type-safe, asynchronous driver for neo4j
- 204Type-safe general-cryptography library - https://jmcardon.github.io/tsec/
https://github.com/jmcardon/tsec
Type-safe general-cryptography library - https://jmcardon.github.io/tsec/ - jmcardon/tsec
- 205JSON library
https://github.com/json4s/json4s
JSON library. Contribute to json4s/json4s development by creating an account on GitHub.
- 206Web & mobile client-side akka-http sessions, with optional JWT support
https://github.com/softwaremill/akka-http-session
Web & mobile client-side akka-http sessions, with optional JWT support - softwaremill/akka-http-session
- 207Lightweight and Nonintrusive Scala Dependency Injection Library
https://github.com/softwaremill/macwire
Lightweight and Nonintrusive Scala Dependency Injection Library - softwaremill/macwire
- 208Rings: efficient JVM library for polynomial rings
https://github.com/PoslavskySV/rings
Rings: efficient JVM library for polynomial rings. Contribute to PoslavskySV/rings development by creating an account on GitHub.
- 209Typesafe, purely functional Computational Intelligence
https://github.com/ciren/cilib
Typesafe, purely functional Computational Intelligence - ciren/cilib
- 210An experimental library for Functional Reactive Programming in Scala
https://github.com/lihaoyi/scala.rx
An experimental library for Functional Reactive Programming in Scala - lihaoyi/scala.rx
- 211New ReactiveCouchbase driver using reactive-streams
https://github.com/ReactiveCouchbase/reactivecouchbase-rs-core
New ReactiveCouchbase driver using reactive-streams - ReactiveCouchbase/reactivecouchbase-rs-core
- 212Simple, safe and intuitive Scala I/O
https://github.com/pathikrit/better-files
Simple, safe and intuitive Scala I/O. Contribute to pathikrit/better-files development by creating an account on GitHub.
- 213Reactive type-safe Scala driver for SQL databases
https://github.com/outworkers/morpheus
Reactive type-safe Scala driver for SQL databases. Contribute to outworkers/morpheus development by creating an account on GitHub.
- 214Lamma schedule generator for Scala is a professional schedule generation library for periodic schedules like fixed income coupon payment, equity deravitive fixing date generation etc.
https://github.com/maxcellent/lamma
Lamma schedule generator for Scala is a professional schedule generation library for periodic schedules like fixed income coupon payment, equity deravitive fixing date generation etc. - GitHub - m...
- 215Tiny High Performance HTTP Server for Scala
https://github.com/analogweb/analogweb-scala
Tiny High Performance HTTP Server for Scala . Contribute to analogweb/analogweb-scala development by creating an account on GitHub.
- 216A test framework that runs everything in parallel.
https://github.com/disneystreaming/weaver-test
A test framework that runs everything in parallel. - GitHub - disneystreaming/weaver-test: A test framework that runs everything in parallel.
- 217Clickhouse Scala Client with Reactive Streams support
https://github.com/crobox/clickhouse-scala-client
Clickhouse Scala Client with Reactive Streams support - crobox/clickhouse-scala-client
- 218Memcached client for Scala
https://github.com/monix/shade
Memcached client for Scala. Contribute to monix/shade development by creating an account on GitHub.
- 219A schema-aware Scala library for data transformation
https://github.com/galliaproject/gallia-core
A schema-aware Scala library for data transformation - galliaproject/gallia-core
- 220Efficient CBOR and JSON (de)serialization in Scala
https://github.com/sirthias/borer
Efficient CBOR and JSON (de)serialization in Scala - sirthias/borer
- 221A purely functional Scala client for CouchDB
https://github.com/beloglazov/couchdb-scala
A purely functional Scala client for CouchDB. Contribute to beloglazov/couchdb-scala development by creating an account on GitHub.
- 222The Play JSON library
https://github.com/playframework/play-json
The Play JSON library. Contribute to playframework/play-json development by creating an account on GitHub.
- 223Image comparison by hash codes
https://github.com/poslegm/scala-phash
Image comparison by hash codes. Contribute to poslegm/scala-phash development by creating an account on GitHub.
- 224Avro schema generation and serialization / deserialization for Scala
https://github.com/sksamuel/avro4s
Avro schema generation and serialization / deserialization for Scala - sksamuel/avro4s
- 225Scala combinator library for working with binary data
https://github.com/scodec/scodec
Scala combinator library for working with binary data - scodec/scodec
- 226Minimal, idiomatic, customizable validation Scala library.
https://github.com/yakivy/dupin
Minimal, idiomatic, customizable validation Scala library. - yakivy/dupin
- 227An implementation of an OAuth2 server designed for mocking/testing
https://github.com/zalando-stups/OAuth2-mock-play
An implementation of an OAuth2 server designed for mocking/testing - zalando-stups/OAuth2-mock-play
- 228A type-safe, reflection-free, powerful enumeration implementation for Scala with exhaustive pattern match warnings and helpful integrations.
https://github.com/lloydmeta/enumeratum
A type-safe, reflection-free, powerful enumeration implementation for Scala with exhaustive pattern match warnings and helpful integrations. - lloydmeta/enumeratum
- 229Optics library for Scala
https://github.com/optics-dev/Monocle
Optics library for Scala. Contribute to optics-dev/Monocle development by creating an account on GitHub.
- 230Scala etcd client implementing V3 APIs
https://github.com/mingchuno/etcd4s
Scala etcd client implementing V3 APIs. Contribute to mingchuno/etcd4s development by creating an account on GitHub.
- 231An asynchronous programming facility for Scala
https://github.com/scala/scala-async
An asynchronous programming facility for Scala. Contribute to scala/scala-async development by creating an account on GitHub.
- 232Accord: A sane validation library for Scala
https://github.com/wix/accord
Accord: A sane validation library for Scala. Contribute to wix-incubator/accord development by creating an account on GitHub.
- 233A data access library for Scala + Postgres.
https://github.com/tpolecat/skunk
A data access library for Scala + Postgres. Contribute to typelevel/skunk development by creating an account on GitHub.
- 234tinylog is a lightweight logging framework for Java, Kotlin, Scala, and Android
https://github.com/tinylog-org/tinylog
tinylog is a lightweight logging framework for Java, Kotlin, Scala, and Android - tinylog-org/tinylog
- 235A purely functional library to build distributed and event-driven systems
https://github.com/parapet-io/parapet
A purely functional library to build distributed and event-driven systems - parapet-io/parapet
- 236Non-blocking, Reactive Redis driver for Scala (with Sentinel support)
https://github.com/etaty/rediscala
Non-blocking, Reactive Redis driver for Scala (with Sentinel support) - etaty/rediscala
- 237Wonderful reusable code from Twitter
https://github.com/twitter/util
Wonderful reusable code from Twitter. Contribute to twitter/util development by creating an account on GitHub.
- 238The Scala API for Quantities, Units of Measure and Dimensional Analysis
https://github.com/typelevel/squants
The Scala API for Quantities, Units of Measure and Dimensional Analysis - typelevel/squants
- 239Squid – type-safe metaprogramming and compilation framework for Scala
https://github.com/epfldata/squid
Squid – type-safe metaprogramming and compilation framework for Scala - epfldata/squid
- 240Principled Functional Programming in Scala
https://github.com/scalaz/scalaz
Principled Functional Programming in Scala. Contribute to scalaz/scalaz development by creating an account on GitHub.
- 241sbt plugin that generates Scala case classes for easy, statically typed and implicit access of JSON data e.g. from API responses
https://github.com/battermann/sbt-json
sbt plugin that generates Scala case classes for easy, statically typed and implicit access of JSON data e.g. from API responses - battermann/sbt-json
- 242Accelerate local LLM inference and finetuning (LLaMA, Mistral, ChatGLM, Qwen, Baichuan, Mixtral, Gemma, Phi, MiniCPM, etc.) on Intel CPU and GPU (e.g., local PC with iGPU, discrete GPU such as Arc, Flex and Max); seamlessly integrate with llama.cpp, Ollama, HuggingFace, LangChain, LlamaIndex, GraphRAG, DeepSpeed, vLLM, FastChat, Axolotl, etc.
https://github.com/intel-analytics/BigDL
Accelerate local LLM inference and finetuning (LLaMA, Mistral, ChatGLM, Qwen, Baichuan, Mixtral, Gemma, Phi, MiniCPM, etc.) on Intel CPU and GPU (e.g., local PC with iGPU, discrete GPU such as Arc,...
- 243Mockito for Scala language
https://github.com/mockito/mockito-scala
Mockito for Scala language. Contribute to mockito/mockito-scala development by creating an account on GitHub.
- 244High-performance SLF4J wrapper for Scala.
https://github.com/Log4s/log4s
High-performance SLF4J wrapper for Scala. Contribute to Log4s/log4s development by creating an account on GitHub.
- 245🔍 Elasticsearch Scala Client - Reactive, Non Blocking, Type Safe, HTTP Client
https://github.com/sksamuel/elastic4s
🔍 Elasticsearch Scala Client - Reactive, Non Blocking, Type Safe, HTTP Client - Philippus/elastic4s
- 246aossie / Agora · GitLab
https://gitlab.com/aossie/Agora/
An Electronic Voting Library implemented in Scala
- 247aossie / Scavenger · GitLab
https://gitlab.com/aossie/Scavenger
A theorem prover based on the conflict resolution calculus
- 248SBT plugin for tweaking various IDE settings
https://github.com/JetBrains/sbt-ide-settings
SBT plugin for tweaking various IDE settings. Contribute to JetBrains/sbt-ide-settings development by creating an account on GitHub.
- 249An HTTP Server and Client library for Scala.
https://github.com/criteo/lolhttp
An HTTP Server and Client library for Scala. Contribute to criteo/lolhttp development by creating an account on GitHub.
- 250Scalafmt · Code formatter for Scala
https://scalameta.org/scalafmt/
Code formatter for Scala
- 251sbt plugin that can check Maven and Ivy repositories for dependency updates
https://github.com/rtimush/sbt-updates
sbt plugin that can check Maven and Ivy repositories for dependency updates - rtimush/sbt-updates
- 252Scala command-line wrapper around ffmpeg, ffprobe, ImageMagick, and other tools relating to media.
https://github.com/outr/media4s
Scala command-line wrapper around ffmpeg, ffprobe, ImageMagick, and other tools relating to media. - outr/media4s
- 253friendly little parsers
https://github.com/tpolecat/atto
friendly little parsers. Contribute to tpolecat/atto development by creating an account on GitHub.
- 254simple combinator-based parsing for Scala. formerly part of the Scala standard library, now a separate community-maintained module
https://github.com/scala/scala-parser-combinators
simple combinator-based parsing for Scala. formerly part of the Scala standard library, now a separate community-maintained module - scala/scala-parser-combinators
Related Articlesto learn about angular.
- 1Introduction to Scala: Beginner’s Guide
- 2Understanding Scala’s Type System: Types and Generics
- 3Functional Programming with Scala
- 4Advanced Functional Programming in Scala: Monads, Functors, and More
- 5Building RESTful APIs with Scala and Akka HTTP: A Beginner’s Guide
- 6Play Framework for Scala Web Development: A Step-by-Step Guide
- 7Concurrency in Scala: Mastering Futures and Promises
- 8Optimizing Scala Performance: Tips for High-Performance Scala Applications
- 9Developing a Scala-based Chat Application: From Concept to Deployment
- 10Creating a Scala-based Data Processing Pipeline: Handling Big Data Efficiently
FAQ'sto learn more about Angular JS.
mail [email protected] to add more queries here 🔍.
- 1
can scala do functional programming
- 2
is scala worth learning in 2023
- 3
is scala popular
- 4
is scala a popular language
- 5
why was scala created
- 6
is scala better than python
- 7
can scala use java libraries
- 8
what is the paradigm of the scala programming language
- 9
why use scala programming language
- 10
should i learn scala
- 11
is scala a good language
- 12
is scala a programming language
- 13
where is la scala opera house located
- 14
when was scala created
- 15
how does scala work
- 16
where is scala installed on windows
- 17
why scala is called functional programming language
- 18
does scala use jvm
- 19
where is scala programming language used
- 20
what is scala software
- 21
why learn scala
- 22
why scala over java
- 23
why scala over python
- 24
- 25
where scala is used
- 26
how to learn scala programming
- 27
is scala a popular programming language
- 28
where is la scala located
- 30
who developed scala
- 31
what is scala code
- 32
why scala is not popular
- 33
- 34
- 35
which of the following programming paradigm does scala support
- 36
- 37
can i use scala code in java
- 38
how is scala different from python
- 39
who created scala
- 40
when scala spark
- 41
is scala dead 2023
- 42
who invented scala
- 43
where is la scala located in italy
- 44
- 45
why scala is functional programming language
- 46
is scala open source
- 47
what is scala mostly used for
- 48
is scala written in java
- 49
is scala a dying language
- 50
what is scala programming language used for
- 51
is scala a good programming language
- 52
why scala is better than java
- 53
what is scala programming
- 54
when to use scala
- 55
can i learn scala without java
- 56
does scala compile to java
- 57
why scala is used
- 58
what is functional programming in scala
- 59
should i learn scala reddit
- 60
should i learn java or scala
- 61
how to pronounce scala programming language
- 63
does scala run on jvm
- 64
what is scala programming used for
- 65
who uses scala programming language
- 66
is scala functional programming
More Sitesto check out once you're finished browsing here.
https://www.0x3d.site/
0x3d is designed for aggregating information.
https://nodejs.0x3d.site/
NodeJS Online Directory
https://cross-platform.0x3d.site/
Cross Platform Online Directory
https://open-source.0x3d.site/
Open Source Online Directory
https://analytics.0x3d.site/
Analytics Online Directory
https://javascript.0x3d.site/
JavaScript Online Directory
https://golang.0x3d.site/
GoLang Online Directory
https://python.0x3d.site/
Python Online Directory
https://swift.0x3d.site/
Swift Online Directory
https://rust.0x3d.site/
Rust Online Directory
https://scala.0x3d.site/
Scala Online Directory
https://ruby.0x3d.site/
Ruby Online Directory
https://clojure.0x3d.site/
Clojure Online Directory
https://elixir.0x3d.site/
Elixir Online Directory
https://elm.0x3d.site/
Elm Online Directory
https://lua.0x3d.site/
Lua Online Directory
https://c-programming.0x3d.site/
C Programming Online Directory
https://cpp-programming.0x3d.site/
C++ Programming Online Directory
https://r-programming.0x3d.site/
R Programming Online Directory
https://perl.0x3d.site/
Perl Online Directory
https://java.0x3d.site/
Java Online Directory
https://kotlin.0x3d.site/
Kotlin Online Directory
https://php.0x3d.site/
PHP Online Directory
https://react.0x3d.site/
React JS Online Directory
https://angular.0x3d.site/
Angular JS Online Directory