plokhotnyuk/jsoniter-scala

This system is a high-performance JSON serialization and deserialization library for Scala, supporting JVM, Scala.js, and Scala Native platforms. It provides a core engine for iterative parsing and a macro-based code generator that derives codecs for complex data structures, including Scala 3 enums and named tuples. The project also includes a comprehensive benchmarking suite to measure and compare the performance of various JSON libraries across different runtimes and data types.

18 changes.

The project underwent a major architectural shift to support Scala.js and Scala Native, replacing the legacy macro-based codec implementation with a new core library featuring configurable readers and writers. This period also involved a comprehensive build system overhaul for cross-compilation, the automation of release processes, and the addition of extensive test coverage and benchmarking utilities across all supported platforms.

24 changes.

This period focused on expanding the jsoniter-scala ecosystem by introducing a new Circe integration module with configurable serialization options and extending Scala Native support. Significant work was also dedicated to enhancing the JsonCodecMaker macro for both Scala 2 and Scala 3, adding comprehensive test coverage for new language features and collection types. Additionally, the benchmark suite was updated to include performance comparisons for new libraries and platforms, including Scala.js and Scala 3.

4 changes.

This period focused on extending jsoniter-scala with full Scala 3 compatibility, including derives syntax support and comprehensive named tuple tests. It also introduced new iterative JsonReader and JsonWriter implementations for JVM and Scala Native to improve performance and fix parsing edge cases, alongside enhanced multi-threaded benchmarking capabilities.

The library now includes a native-specific implementation of ByteArrayAccess in the Scala Native module, enabling direct low-level byte array manipulation (such as get/set operations for Int, Long, and Short) using Scala Native runtime intrinsics. This change provides the necessary infrastructure for efficient binary data handling on Scala Native platforms, complementing the existing JVM implementation.

jsoniter-scala-core/native/src/main · high confidence

The benchmark suite now includes JVM-specific support for Play JSON, introducing a \PlatformUtils\ object that provides a pretty-printing function for \JsValue\ instances using Jackson's \ObjectMapper\ and the \PlayJsonMapperModule\. This change also adds a \Suit\ enum and a \PlatformSpecificPlayJsonFormats\ trait to support the benchmark infrastructure on the JVM platform.

jsoniter-scala-benchmark/jvm/src/main · high confidence

New Scala 3-specific benchmark suites have been added for the Scala.js target, enabling performance comparison of JSON libraries (including borer, circe, play-json, zio-json, and others) in JavaScript environments. The entry point (Main.scala) configures the benchmark GUI with a 7-second warm-up period and defines suites for reading and writing arrays of various types (BigDecimals, BigInts, Booleans, Bytes, Chars, Doubles) with a fixed size of 512 elements.

jsoniter-scala-benchmark/js/src/main/scala-3 · high confidence

The Scala 3 benchmark suite now includes reading and writing benchmarks for arrays of BigDecimal, BigInt, Boolean, Byte, Char, and Double. These additions allow users to compare the serialization and deserialization performance of these specific data types across supported JSON libraries in the Scala 3 environment.

jsoniter-scala-benchmark/shared/src/main/scala-3 · high confidence

The jsoniter-scala-circe module now supports Scala Native, enabling users to run JSON serialization and deserialization with circe codecs on Native platforms. This change introduces platform-specific utilities, such as the new StringUtil implementation in the jvm-native source directory, which provides efficient string conversion from ASCII byte buffers specifically optimized for the Native environment.

jsoniter-scala-circe/jvm-native · high confidence

New benchmark data models (GeoJSON, NestedStructs, OpenRTB, TwitterAPI) have been added to the Scala.js and Scala Native benchmark modules, providing structured case classes and sealed traits to exercise JSON serialization and deserialization performance across these platforms.

repository · high confidence

The benchmark suite now includes serialization and deserialization performance tests for AVSystem GenCodec and zio-schema-json. The new \AVSystemCodecs\ file provides codec definitions for various data types, while dedicated benchmark classes (e.g., \ArrayOfBigDecimalsReading\, \ArrayOfBooleansWriting\) allow users to compare the performance of these libraries alongside existing ones like circe, jackson, and zio-json.

jsoniter-scala-benchmark/shared/src/main/scala-2 · high confidence

New HTML entry points have been added to the Scala.js benchmark suite, specifically for Scala 2.13 (full optimization) and Scala 3.9.0 (full optimization). These pages load the respective compiled JavaScript assets, enabling users to run and view benchmark results for these specific Scala versions in a browser.

jsoniter-scala-benchmark/js · high confidence

Introduced the main Scala.js benchmark runner (Main.scala) which configures the benchmark GUI with a 7-second warm-up period and defines suites for reading and writing arrays of BigDecimals, BigInts, Booleans, Bytes, and Chars across multiple JSON libraries. Also added a Suit.scala enum to provide structured test data for benchmarking serialization of complex objects.

jsoniter-scala-benchmark/js/src/main/scala-2 · high confidence

The benchmark suite now includes platform-specific support for the JavaScript target, introducing \PlatformSpecificPlayJsonFormats\ to define serialization formats for Java time types (such as \Instant\, \LocalDateTime\, and \ZonedDateTime\) and \PlatformUtils\ to handle timestamp conversions and pretty-printing. These additions enable the benchmark to accurately measure Play JSON performance on Scala.js, complementing the existing JVM benchmarks.

jsoniter-scala-benchmark/js/src/main/scala · high confidence

A new \Util\ object was added to the circe benchmark suite to support more accurate performance comparisons. It introduces a \deepDropEmptyValues\ function that recursively removes null values and empty arrays/objects from JSON structures, addressing a specific benchmarking requirement for the circe library. This utility also includes a helper for constructing JSON objects while filtering out null or empty fields.

jsoniter-scala-benchmark/shared/src/main/scala/io · high confidence

The release workflow is now automated via \release.sbt\, which enforces JDK 11, runs tests and binary compatibility checks (MiMa) across all JVM, JS, and Native modules, updates version strings in the README and example scripts, and publishes signed artifacts to Sonatype. Additionally, \.jvmopts\ introduces specific JVM settings for the build environment, including 6GB max heap, 4MB stack size, G1 garbage collection, and 512MB code cache sizes.

(repo-wide) · high confidence

This change introduces the first complete implementation of the jsoniter-scala-core JSON reader and writer for the Scala.js platform. Previously, the core library was JVM-only; this commit duplicates and adapts the JVM source code to \jsoniter-scala-core/js/src/main\, providing \JsonReader\ and \JsonWriter\ classes that support iterative parsing and serialization of JSON data, including \java.time\ types, \BigInt\/\BigDecimal\, and numeric keys, specifically optimized for the JavaScript environment.

jsoniter-scala-core/js/src/main · high confidence

The benchmark suite now includes abstract test classes for serializing and deserializing arrays of primitive types (Int, Long, Short, Float, Double, Boolean, Byte, Char), arbitrary-precision numbers (BigDecimal, BigInt), Java enums, and various java.time temporal types (Instant, Duration, LocalDate, LocalTime, LocalDateTime, OffsetDateTime, OffsetTime, Period, MonthDay, YearMonth) as well as UUIDs. These additions allow users to measure JSON performance across a wider range of data structures and value sizes.

jsoniter-scala-benchmark/shared/src/main/scala/com · high confidence

The jsoniter-scala-benchmark sub-project now includes dedicated shell scripts (scala2.sh, scala3.sh, and their -t8, -t16, -t24 variants) to execute benchmarks with 8, 16, and 24 threads. These scripts target Scala 2.13.18 and Scala 3.9.0, running against JDK 17, 21, 25, and 28 (including GraalVM variants) to provide granular performance data across different thread counts and JVM versions.

jsoniter-scala-benchmark · high confidence

The examples directory now includes \example03.scala\, which benchmarks \Math.multiplyHigh\ performance, and \example02.sc\, a command-line tool that validates JSON input against the RFC-8259 specification. The \README.md\ has been updated with build and performance measurement instructions for these new examples across various targets including GraalVM native images, Scala Native, and Scala.js.

jsoniter-scala-examples · high confidence

The \jsoniter-scala-circe\ module introduces a new codec implementation that bridges jsoniter-scala and circe. It provides configurable number serialization strategies, including a default serializer and a \jsCompatibleNumberSerializer\ that outputs large integers and high-precision decimals as strings to prevent precision loss in JavaScript environments. The module also includes specific codecs for primitive numeric types (Byte, Short, Int, etc.) and handles UTF-8 encoding explicitly.

jsoniter-scala-circe/shared/src/main/scala/io · high confidence

The \ConfiguredJsonValueCodec\ trait and its \derived\ method are now available in Scala 3, allowing users to derive JSON codecs using the standard \derives\ keyword. This change introduces a wrapper class to inline wrapping methods for more efficient code generation, particularly benefiting Scala.js users by reducing overhead. Users can now provide compile-time configuration via an \inline given CodecMakerConfig\ to customize the derived codec behavior.

jsoniter-scala-macros/shared/src/main/scala-3 · high confidence

The \Codec.scala\ file containing the macro-based \Codec\ implementation and its \Impl\ object has been deleted from the \macros/src/main\ directory. This change removes the previous macro-generated codec logic that handled serialization and deserialization for Scala types, including support for primitives, collections, and custom types via the \materialize\ macro.

macros/src/main · high confidence

The \CodecBenchmark.scala\ file, which contained JMH benchmarks for comparing Jackson and Jsoniter serialization of AnyRefs, Iterables, Maps, and Primitives, has been removed from the benchmark module. This change eliminates the specific benchmark tests and their associated setup code for these data types.

benchmark · high confidence

The \jsoniter-scala-circe\ module's codec factory now accepts a \sortKeys\ parameter, allowing users to configure JSON object fields to be serialized in natural string order, and exposes a \numberSerializer\ parameter to customize how numeric values are encoded. These options are available on the \jsonCodec\ builder, enabling finer control over the output format and performance characteristics of the Circe integration.

jsoniter-scala-circe/shared/src/main/scala/com · high confidence

The jsoniter-scala-core module now exposes the fundamental codec traits (JsonCodec, JsonValueCodec, JsonKeyCodec) and dedicated configuration classes for the reader and writer. Users can tune internal buffer sizes and exception handling behavior via ReaderConfig and WriterConfig, which introduce new options such as hexDumpSize for error diagnostics and configurable maximum buffer limits to prevent OutOfMemoryErrors during large payload parsing. The default internal byte buffer size for both reading and writing has been increased to 32KB to improve performance for larger messages, while stack traces are disabled by default in exceptions to enhance runtime performance.

jsoniter-scala-core/shared/src/main · high confidence

The library now includes a new \ByteArrayAccess\ class that provides efficient, low-level methods for reading and writing integers, shorts, and longs directly to byte arrays using Java VarHandles. This addition supports the underlying performance optimizations for parsing and serialization on the JVM by enabling faster memory access patterns.

jsoniter-scala-core/jvm/src/main · high confidence

The \jsoniter-scala-core\ module now includes dedicated \JsonReader\ and \JsonWriter\ implementations for JVM and Scala Native targets. These new files provide iterative JSON parsing and serialization capabilities, including support for reading and writing \java.time\ values (such as \Duration\, \Period\, \ZoneId\, and \ZonedDateTime\), handling large integers and decimals, and managing internal buffers for streams and byte buffers. This change introduces the core engine logic for these platforms, replacing or supplementing previous implementations to improve performance and fix parsing edge cases.

jsoniter-scala-core/jvm-native · high confidence

The Scala.js module for jsoniter-scala-circe now includes a specialized \StringUtil\ utility that converts byte buffers to strings more efficiently by assuming ASCII encoding. This change improves the performance of serialization and deserialization for \java.time\ and \java.util.UUID\ values, though users should note that this optimization is limited to ASCII-compatible byte sequences.

jsoniter-scala-circe/js · high confidence

The Scala 2-specific macro implementation for \JsonCodecMaker\ has been added, providing the code generation logic for codec derivation on Scala 2 platforms. This includes the \CodecMakerConfig\ class and its builder methods, which allow users to configure serialization behavior such as field name mapping, discriminator handling, and performance optimizations like skipping nested option values or inlining one-value classes.

jsoniter-scala-macros/shared/src/main/scala-2 · high confidence

Added JVM-specific codec tests and stack-overflow verification utilities; Added Java test sources for enum serialization; Added Scala 3 benchmark specifications for primitive and numeric array types; Added Scala 3 benchmark verification tests for Scala.js; Added Scala 3-specific codec derivation tests; Added Scala.js benchmark specs for array serialization of various data types; Added Scala.js-specific test utilities; Added benchmark validation tests for common array data types; Added comprehensive test coverage for Circe codecs and JsoniterScalaCodec; Added comprehensive test suite for JsonCodecMaker; Added comprehensive test suite for jsoniter-scala-core; Added serialization tests for core codecs and configuration objects; Added test fixtures for Scala 3 enums and stack-overflow utilities in JS and Native targets; Added test utilities for Scala Native platform; Added tests for literal types and new Scala 2.13 collections; Added tests for macro compile-time evaluation and Enumeratum integration; Added tests for named tuple serialization in Scala 3; Added unit tests for benchmark utility classes; Removal of legacy CodecSpec test suite.

The build configuration has been completely rewritten to support a multi-platform architecture (JVM, Scala.js, and Scala Native) with cross-compilation. This update upgrades the default Scala version to 2.13.18 and introduces extensive dependency updates for the benchmark and test suites, including scalatest 3.2.20, scala-java-time-tzdb 2.7.0, and various JSON libraries (circe, zio-json, smithy4s, play-json, etc.). It also adds binary compatibility checking via MiMa, configures Scala.js linker optimizations (ES2021, Closure Compiler), and sets up publishing to the Central Portal.

(dependencies) · high confidence

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

• CAI 59 → 52 (-6.7)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 71 → 71 (-0.0)
• Architecture 100 → 81 (-19.0)
• Maturity 52 → 52 (-0.0)
• Readiness 53 → 41 (-12.9)
• Security 73 → 73 (+0.0)

• Documentation: no installation or build instructions (README.md)
• Documentation: no licence statement (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 11) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• Duplicated block (10 lines × 4) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• Duplicated block (10 lines × 4) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonWriter.scala)
• Duplicated block (11 lines × 2) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• Duplicated block (11 lines × 2) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonWriter.scala)
• Duplicated block (11 lines × 2) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonWriter.scala)
• Duplicated block (11 lines × 6) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• Duplicated block (12 lines × 2) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• Duplicated block (13 lines × 2) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• Duplicated block (14 lines × 2) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• Duplicated block (14 lines × 2) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• Duplicated block (14 lines × 2) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• Duplicated block (15 lines × 2) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonWriter.scala)
• Duplicated block (19 lines × 2) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• Duplicated block (26 lines × 2) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• Duplicated block (28–29 lines × 7) (jsoniter-scala-core/jvm-native/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• Duplicated block (37 lines × 3) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• …and 43 more

• Duplicated block (10 lines × 15) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• Duplicated block (10 lines × 2) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonWriter.scala)
• Duplicated block (10 lines × 4) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• Duplicated block (10 lines × 4) (jsoniter-scala-core/jvm-native/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• Duplicated block (10 lines × 4) (jsoniter-scala-core/jvm-native/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• Duplicated block (11 lines × 2) (jsoniter-scala-core/jvm-native/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• Duplicated block (11 lines × 2) (jsoniter-scala-core/jvm-native/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• Duplicated block (11 lines × 2) (jsoniter-scala-core/jvm-native/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonWriter.scala)
• Duplicated block (11 lines × 8) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• Duplicated block (11 lines × 9) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• Duplicated block (12 lines × 2) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• Duplicated block (12 lines × 2) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• Duplicated block (12 lines × 3) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonWriter.scala)
• Duplicated block (12 lines × 3) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonWriter.scala)
• Duplicated block (13 lines × 2) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• Duplicated block (13 lines × 2) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonReader.scala)
• Duplicated block (13 lines × 2) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonWriter.scala)
• Duplicated block (13 lines × 2) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonWriter.scala)
• Duplicated block (14 lines × 2) (jsoniter-scala-core/js/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonWriter.scala)
• Duplicated block (14 lines × 2) (jsoniter-scala-core/jvm-native/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/core/JsonWriter.scala)
• …and 127 more

• 56 commits — 32 feature/other, 24 fixes

• jsoniter-scala-core/js — 20 commits
• (root) — 16 commits
• jsoniter-scala-core/shared — 5 commits
• jsoniter-scala-core/jvm-native — 4 commits
• jsoniter-scala-benchmark/jvm — 3 commits
• jsoniter-scala-circe/shared — 3 commits
• project/plugins.sbt — 3 commits
• jsoniter-scala-benchmark/shared — 1 commit
• jsoniter-scala-circe/js — 1 commit

• fix: Add missing tests and fix missing required field checks for fory-json-scala
• fix: Fix JsonReader to throw JsonReaderException instead of ArithmeticException when parsing java.time.Duration values less than Duration.ofSeconds(Long.MinValue)
• fix: Fix JsonReader to throw JsonReaderException instead of DateTimeException when parsing java.time.Instant values that are out of range because of the timezone offset
• fix: Fix JsonReader.readBytesAsDuration and JsonReader.readBytesAsPeriod to stop reading after the seconds and days parts
• fix: Fix JsonReader.readBytesAsLocalDate to not consume a double quote after the day
• fix: Fix JsonReader.readBytesAsLocalTime and JsonReader.readBytesAsLocalDateTime for Scala.js to leave a byte after seconds unread
• fix: Fix JsonReader.readNumber for Scala.js to return BigInteger instead of BigDecimal for integers with 19-36 digits that don't fit in Long
• fix: Fix JsonWriter for JVM and Scala Native to throw NullPointerException for null values before moving of the position
• fix: Fix JsonWriter.writeBytes for java.time.ZoneId values when the internal buffer is flushed to an output stream or a direct byte buffer
• fix: Fix WASM + JS dependency link in README
• fix: Fix benchmark test failures
• fix: Fix copy-paste mistakes in JsonWriter doc comments
• fix: Fix error messages of JsonReader.readMonthDay for illegal first digits of month or day
• fix: Fix names of MonthDay tests in JsonReaderSpec
• fix: Fix overflow in calculation of the hex dump size for big values of ReaderConfig.hexDumpSize
• fix: Fix overflow of the exponent when parsing Float and Double values with a few fractional digits and huge exponents
• fix: Fix overflow of the scale when parsing BigDecimal values by JsonReader.readBigDecimal and JsonReader.readNumber
• fix: Fix parsing of java.time.* values in JsonReader.readBytes* methods
• fix: Fix parsing of integers with more than 36 digits and a zero exponent by JsonReader.readNumber
• fix: Fix parsing of numbers with 19-36 digits and leading zeros for Scala.js
• …and 36 more

• Unchanged — 0 containers · 1 contexts · 0 edges

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

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