Skip to content
CAI
Software that uses CAICheck a score

edgurgel/solid

70.4

Strong · 15 November 2026

5k

lines of production code

Elixir

primary language

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Added Liquid template benchmarking suite

A new benchmarking harness has been added to the \bench\ directory to measure the performance of \Solid.parse/2\ and \Solid.render/3\. The suite uses Benchee to run a set of Liquid template fixtures (vendored from the \golden-liquid\ project) and reports timing and memory metrics. It includes a custom file system implementation to handle partials and automatically skips fixtures that cannot be parsed, such as those using the deprecated \{% include %}\ tag.

bench · high confidence

Initial implementation of Liquid template tags

This release introduces the core set of Liquid tags for the Solid templating engine, including \assign\, \capture\, \case\, \comment\, \for\, \if\/\unless\, \render\, \tablerow\, \cycle\, \counter\, \echo\, \raw\, and control flow tags like \break\ and \continue\. These additions enable users to perform variable assignment, conditional rendering, iteration with loop variables, template inclusion, and structured output generation within their templates.

lib/solid/tags · high confidence

Removals

Removed PEG compilation task

The \tasks/compile.peg.exs\ file, which previously handled the compilation of Erlang Parsing Expression Grammars (PEGs) using the \:neotoma\ library, has been deleted. This change removes the custom Mix task responsible for managing PEG source files and their compiled artifacts.

tasks · high confidence

Removed legacy PEG parser implementation

The file \src/solid\_parser.peg\, which contained the previous PEG-based parser implementation for the Solid template engine, has been deleted. This change removes the old parsing logic (including rules for fields, filters, arguments, and values) from the codebase, likely as part of the rewrite mentioned in commit messages to use Nimble Parsec, though the new implementation files are not included in this specific diff excerpt.

src · high confidence

Behavioural changes

Major API overhaul with strict parsing and new error handling

The library has been rewritten to use Nimble Parsec, introducing a strict parsing mode that diverges from the original Liquid specification by supporting filters inside conditional tags (if/elsif/unless) via the new \filters\_in\_conditional\_tags\ option. The public API has changed significantly: \parse/1\ is now \parse/2\ returning \{:ok, template} \| {:error, TemplateError.t()}\, and \render/2\ is now \render/3\ accepting a \Template\ struct, a context map, and options like \strict\_variables\, \strict\_filters\, and \custom\_filters\. New error types (\RenderError\, \ParserError\, \TemplateError\) provide detailed feedback on parsing and rendering issues, and a new caching interface (\Solid.Caching.NoCache\) is included.

lib · high confidence

Rewritten parser and stricter rendering behavior

The template parsing engine has been rewritten from scratch using Nimble Parsec, replacing the previous neotoma-based parser. This change introduces stricter parsing that collects all errors rather than stopping at the first one, and alters the return signature of \Solid.parse/2\ to provide more detailed error information. Additionally, \Solid.render/3\ now returns a \{:ok, result, errors}\ tuple by default, allowing users to handle rendering issues gracefully, while \Solid.render!/3\ raises on errors when strict mode is enabled. Custom tags must now be implemented using the new \Solid.Parser\ and \Solid.Lexer\ interfaces.

(repo-wide) · high confidence

Solid Liquid template engine rewritten with NimbleParsec

The Solid Liquid template engine has been completely rewritten to use NimbleParsec, replacing the previous parser implementation. This change introduces a new set of internal modules for parsing and rendering Liquid templates, including Solid.Lexer, Solid.Parser, Solid.Context, and Solid.StandardFilter, along with supporting modules for access literals, variables, conditions, and file systems. The rewrite maintains compatibility with existing Liquid template syntax while providing a more robust and performant parsing foundation.

lib/solid · high confidence

Test coverage

Added comprehensive test coverage for Solid template parsing and rendering; Added test coverage for Solid template tags; Added test support infrastructure for Liquid template integration testing; Expanded integration test coverage for Solid template engine; Expanded test suite for Solid parser and renderer.

Dependencies

Major dependency overhaul and Elixir 1.17 requirement

The project has been updated to require Elixir \~\> 1.17 and replaced the legacy Neotoma parser with the Decimal library for numeric handling. Development tooling has been modernized by upgrading ExDoc to 0.40.3 (which now uses EarmarkParser instead of Earmark), adding Jason for JSON processing, and introducing Benchee for benchmarking. The build configuration also consolidates protocols in non-test environments and adjusts compiler paths to support test helpers.

(dependencies) · high confidence

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

How this codebase got here

Score

  • CAI 68 → 70 (+1.9)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 96 → 93 (-3.1)
  • Architecture 100 → 100 (-0.0)
  • Maturity 54 → 59 (+4.7)
  • Readiness 72 → 72 (+0.0)
  • Security 99 → 98 (-0.3)
  • Performance 80 → 80 (+0.0)

Resolved (3)

  • Further sole-owners (lower concentration)
  • Hotspot: lib/solid/lexer.ex (lib/solid/lexer.ex)
  • Off-boarding risk: anonymized user #1

New (13)

  • Edited copies of one member (3 members, 7+ corresponding lines) (lib/solid/tags/assign_tag.ex)
  • Edited copies of one member (3 members, 9+ corresponding lines) (lib/solid/tags/case_tag.ex)
  • Edited copies of one member (5 members, 10+ corresponding lines) (lib/solid/tags/for_tag.ex)
  • Edited copy of a member (10 corresponding lines) (lib/solid/tags/for_tag.ex)
  • Edited copy of a member (13 corresponding lines) (lib/solid/tags/if_tag.ex)
  • Edited copy of a member (16 corresponding lines) (lib/solid/tags/for_tag.ex)
  • Edited copy of a member (18 corresponding lines) (lib/solid/tags/for_tag.ex)
  • Edited copy of a member (20 corresponding lines) (lib/solid/tags/for_tag.ex)
  • Edited copy of a member (3 corresponding lines) (lib/solid/tags/for_tag.ex)
  • Edited copy of a member (4 corresponding lines) (lib/solid/tags/for_tag.ex)
  • Edited copy of a member (8 corresponding lines) (lib/solid/tags/counter_tag.ex)
  • Edited copy of a member (9 corresponding lines) (lib/solid/tags/for_tag.ex)
  • Off-boarding risk: anonymized user #1

Changes since last survey

  • 2 commits — 0 feature/other, 2 fixes

By area

  • lib/solid — 1 commit
  • test/solid — 1 commit

Notable commits

  • fix: fix: Structs return {:error, :protocol_not_implemented} (#187)
  • fix: fix: read size and first as variables (#216)

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

Survey your own repository

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

About this page

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