creativescala/doodle

Doodle is a Scala library for declarative computer graphics that provides a unified algebraic API for creating and manipulating visual elements like shapes, text, and images. It supports rendering to multiple backends, including JVM-based Java2D and JavaScript-based HTML Canvas and SVG, enabling both static image export and interactive, animated experiences. The system features advanced capabilities for image processing, such as CSS blend modes and filters, alongside tools for procedural generation and smooth animation interpolation.

36 changes.

The project underwent a major migration to Scala 3 and Apache 2.0 licensing, rebranding as Doodle and restructuring its build system with sbt-typelevel. This period saw the introduction of multiple rendering backends, including Java2D, HTML Canvas, and SVG for both JVM and JavaScript platforms, alongside a comprehensive interactive animation system built on Cats Effect and fs2.

21 changes.

This period introduced a new HTML Canvas backend and expanded the algebraic foundation with support for image filters, blend modes, and platform-specific bitmap handling. The work included significant refactoring of image syntax and animation execution to align with Scala 3 and cats-effect, alongside comprehensive property-based and golden tests to ensure correctness across the new features.

Introduces a new SVG rendering backend for the JavaScript platform, enabling users to generate SVG graphics in browser environments. This change adds the \JsBase\ trait and \package.scala\ definitions that wire up the Scala.js DOM types (\dom.Element\, \dom.Node\) and the \scalatags.JsDom\ bundle to the existing algebraic structure, providing implicit renderers and animation handlers specifically for the JS target.

svg/js/src/main/scala/doodle/svg · high confidence

The \image/shared/src/main/scala/doodle/image/examples\ directory now includes a comprehensive suite of example files showcasing the library's capabilities. These examples demonstrate image composition techniques (such as \ArcheryTarget\, \ChessBoard\, and \Layers\), gradient rendering (\GradientCircles\, \GradientSquares\), and the use of the random algebra for procedural generation (\BrownianMotion\, \DiffusionLimitedAggregation\, \Layers\). Additional examples cover geometric patterns (\Epicycloid\, \Hypocycloid\, \Koch\), color manipulation (\ColorPalette\, \ColorWheel\), and path handling (\OpenClosedPaths\, \FunctionalGeometry\).

image/shared/src/main/scala/doodle/image/examples · high confidence

A new Orbit example has been added to the interact examples, showcasing how to generate a stream of Picture frames using fs2. The example renders a brown circle that orbits by rotating its fill color and position based on an angle, illustrating the use of the Picture type and fs2 Stream for animation.

interact/shared/src/main/scala/doodle/interact/examples · high confidence

The \interact\ module now includes an \Easing\ trait and companion object that provide standard easing functions (such as linear, quadratic, cubic, sin, circle, back, and elastic) for use in animations. This allows users to define how values change over time with more natural motion curves, supporting composition via \followedBy\ and \reflect\ methods, and integration with fs2 Streams for step-based animation sequences.

interact/shared/src/main/scala/doodle/interact/easing · high confidence

New example files have been added to the turtle/shared module, demonstrating how to use the turtle graphics API to generate geometric shapes, L-system fractals (trees, flowers, Koch curves), and recursive patterns like square spirals. These examples showcase the updated Scala 3 syntax and the \doodle.syntax.all.\_\ import structure for creating and rendering turtle instructions.

turtle/shared · high confidence

Added a collection of JavaScript-exported example programs for the HTML Canvas backend, demonstrating capabilities such as blend modes, frame backgrounds, layout, text rendering, style, parametric spirals, concentric circles, and loading/converting bitmaps (including HTMLImageElement and ImageBitmap) to pictures.

examples/js/src/main/scala/doodle/examples/canvas · high confidence

This change introduces a new HTML Canvas rendering backend for Doodle, enabling users to render vector graphics, text, and images directly in the browser. The implementation includes algebraic support for drawing shapes (rectangles, circles, triangles), paths, and styled text, as well as gradient fills and CSS blend modes for compositing. It also provides capabilities to load images from URLs (as HTMLImageElement or ImageBitmap) and convert existing DOM image elements into Doodle pictures, along with an animation renderer for streaming frame updates.

canvas · high confidence

This change introduces the core algebraic structures and rendering logic for generating SVG output in the JavaScript environment. It adds the \JsAlgebra\ trait and its implementation, which integrates with the Cats effect system to handle drawing operations. The update includes specific modules for rendering text (with correct bounding box and baseline handling), applying CSS-style blends, filters, gradients, and interactive features like mouse clicks and moves. It also provides utilities for adding HTML attributes and links to SVG elements, along with a basic example demonstrating how to draw pictures to a canvas.

svg/js/src/main/scala/doodle/svg/algebra · high confidence

The SVG rendering capability is now available on the JVM platform through a new \JvmBase\ trait and associated package definitions. This change establishes the necessary type aliases (such as \Builder\ and \Output\) and wiring for the \scalatags\ library, enabling users to generate SVG graphics as strings on the JVM, mirroring the existing JavaScript implementation.

svg/jvm/src/main/scala/doodle/svg · high confidence

The algebra module now defines the \Filter\ and \Blend\ traits, providing a structured API for image processing. The \Filter\ algebra introduces operations for visual effects including Gaussian and box blurs, edge detection, sharpening, embossing, and drop shadows, along with standard convolution kernels. The \Blend\ algebra adds support for all CSS blend modes (such as multiply, screen, overlay, and hue) to control how images composite. Generic implementations for these capabilities are also provided in the \generic\ subpackage to support backend-specific rendering.

algebra/shared/src/main · high confidence

A new \Sampler\ trait and companion object have been added to the \doodle.random\ package, providing a structured way to generate sequences of random values. This change introduces specific sampling strategies including \random\ for uniform selection, \cyclic\ for ordered iteration, and \noRepeats\ to ensure consecutive selections differ, replacing or supplementing previous ad-hoc randomization logic.

core/shared/src/main/scala/doodle/random · high confidence

A new \Format.scala\ file has been added to the core library, defining a \Format\ marker trait and specific sealed traits for standard image formats including PDF, GIF, PNG, SVG, and JPEG. This establishes the type-level representation for image formats used by the respective writers, allowing the system to distinguish between different output types at compile time.

core/shared/src/main/scala/doodle/core/format · high confidence

The JVM-specific SVG writer has been implemented to allow rendering pictures to both local files and Base64-encoded strings. This change introduces the \SvgWriter\ object, which leverages the \FileWriter\ and \Base64Writer\ traits to provide concrete output mechanisms for SVG graphics on the JVM, enabling users to save SVGs directly or retrieve them as encoded data.

svg/jvm/src/main/scala/doodle/svg/effect · high confidence

The Java2D backend algebra in \doodle.java2d.algebra\ now provides concrete rendering and image-loading capabilities. It implements shape primitives (rectangles, circles, polygons, and paths) via \Graphics2DGraphicsContext\, including a fix for filled circles that uses \fillOval\ instead of the previous approach. Text rendering is supported using the current stroke and fill settings, with an internal vertical reflection applied to correct orientation. The backend also introduces bitmap support: \Java2dLoadBitmap\ allows loading images from \File\ or \Path\ sources, while \Java2dFromBufferedImage\, \Java2dFromBase64\, and \Java2dToPicture\ enable displaying \BufferedImage\ instances and images encoded as Base64 (PNG, GIF, JPG) as pictures. Gradient support is reinstated for both fills and strokes, mapping linear and radial gradients to Java2D paint objects.

java2d/src/main/scala/doodle/java2d/algebra · high confidence

The \doodle.java2d\ package now provides a unified entry point that automatically wires up support for rendering to GIF, PNG, JPG, and PDF formats, as well as writing to \BufferedImage\ and loading bitmaps from files or paths. Additionally, it enables interactive canvas features such as mouse clicks and moves, and supports animation rendering, making these capabilities immediately available to users importing the package without manual configuration.

java2d/src/main/scala/doodle/java2d · high confidence

The \doodle.interact.effect\ package now introduces two new typeclasses: \AnimationRenderer\, which defines how to animate frames produced by an fs2 Stream onto a Canvas, and \AnimationWriter\, which extends the existing Writer interface to support writing animations to files. These changes provide a structured, type-safe API for rendering and exporting animations, replacing the previous ad-hoc approach and aligning with the broader migration to fs2 for stream processing.

interact/shared/src/main/scala/doodle/interact/effect · high confidence

This release introduces a new HTML Canvas backend for Doodle, allowing users to render graphics directly in the browser via the \CanvasRenderingContext2D\. The backend supports interactive mouse events (move and click) and animation loops using \requestAnimationFrame\. To support this and other backends, the library introduces a new \DrawingContext\ algebra that unifies stroke and fill styles, including support for gradients, and a \Finalized\ type for calculating bounding boxes and rendering. Core types like \Color\ (now supporting Oklch), \Gradient\, \Path\, and \Landmark\ have been restructured to support these new capabilities.

repository · high confidence

Added a new example file, SvgTaggedJvmExample.scala, which demonstrates how to create an SVG image containing a clickable link. The example constructs a picture with a regular polygon and text, applies a hyperlink to 'https://creativescala.org/', and writes the result to 'link\_tagged.svg'.

examples/jvm · high confidence

Added five new example programs in the Java2D backend: BouncyCircles demonstrates multi-easing animation and GIF export; Dash shows dashed stroke rendering with animated size changes; EmptyFrame provides a minimal canvas initialization test; Pointillism introduces mouse-click interactivity to draw interpolating splines; and PulsingCircle features an animated concentric disk effect with GIF export. These examples showcase the updated syntax, fs2-based animation streams, and new interaction capabilities in the Java2D rendering context.

java2d/src/main/scala/doodle/java2d/examples · high confidence

The JVM module now includes a new Reactor-based animation system, providing syntax extensions and example implementations (such as easing functions) that allow users to create and render animated graphics using Cats Effect IO.

reactor/jvm · high confidence

The JavaScript backend now includes dedicated \SvgRenderer\ and \SvgAnimationRenderer\ implementations. \SvgRenderer\ provides the core capability to render Doodle pictures to SVG canvases, while \SvgAnimationRenderer\ enables streaming animation support by processing frames and combining their results. These changes establish the foundational rendering infrastructure for SVG output on JS.

svg/js/src/main/scala/doodle/svg/effect · high confidence

Added a suite of new JavaScript/Scala.js example applications in the SVG package, including demonstrations for SVG attributes (such as custom styles and click handlers), CSS blend modes, bouncy circle animations, various image filters (blur, sharpen, edge detection, emboss), parametric spirals, tagged links, and text rendering. These examples showcase the SVG algebra's capabilities for interactive and visual effects in the browser.

examples/js/src/main/scala/doodle/examples/svg · high confidence

The animation module now includes a new \Interpolator\ trait and implementation that allows users to generate smooth transitions between values. This feature supports both half-open and closed intervals, applies configurable easing functions to modify the speed of transitions, and utilizes Kahan summation for Double types to reduce floating-point accumulation errors during interpolation.

interact/shared/src/main/scala/doodle/interact/animation · high confidence

A new set of Scala.js examples has been added to the Doodle JavaScript distribution, providing a unified, backend-agnostic way to explore the library's capabilities. The suite introduces a \BaseExamples\ utility trait that automatically aggregates and vertically stacks individual examples, simplifying how users view and test different features. This new structure includes dedicated example modules for Blend modes (demonstrating all CSS blend modes), Layout (covering positioning, margins, and debugging), Style (showcasing fills, strokes, and gradients), and Text (displaying font families and styling). Additionally, specific interactive and static demos like ConcentricCircles, DoodleLogo, PulsingCircle, and ParametricSpiral are now included, allowing users to easily experiment with animation, SVG rendering, and geometric patterns in a consistent, reusable format.

examples/js/src/main/scala/doodle/examples · high confidence

This change introduces foundational core types and expanded color resources. It adds an \Angle\ class with arithmetic, normalization, and conversion utilities, along with syntax extensions for convenient creation from numeric values. A new \Coordinate\ enum supports absolute points, percentages, and arithmetic operations for flexible layout positioning. The library also expands its color offerings with \CommonColors\ and \CrayolaColors\ (RGB/hex-based) and introduces \Tailwind4Colors\, which defines the Tailwind CSS 4.0 palette using the OkLCh color space, replacing older HSL-based definitions.

core/shared/src/main/scala/doodle/core · high confidence

Added two new example files in the JVM image examples package: Background.scala demonstrates setting a background color on a frame, and Write.scala demonstrates exporting images to PNG and PDF files as well as generating base64-encoded strings.

image/jvm/src/main/scala/doodle/image/examples · high confidence

The image syntax layer now provides \drawWithFrame\ and \draw\ methods on \Image\ objects, allowing users to render images with explicit frame configurations or using a default frame type class. Additionally, a new \TraverseImageSyntax\ trait adds \allOn\, \allBeside\, and \allAbove\ methods to collections of images, enabling convenient composition of multiple images into a single result.

image/shared/src/main/scala/doodle/image/syntax · high confidence

The \interact/shared/src/main/scala/doodle/interact/algebra\ package now includes new algebraic interfaces for handling user interaction and rendering cycles. Specifically, \MouseClick\ and \MouseMove\ traits provide streams of \Point\ events corresponding to click and movement actions within the canvas's global coordinate system, while \Redraw\ offers a stream indicating when the canvas is ready to render the next frame. Additionally, \MouseOver\ has been added to support hover event listeners on drawing elements.

interact/shared/src/main/scala/doodle/interact/algebra · high confidence

This change introduces a new set of syntax extensions in the \doodle.interact.syntax\ package to support interactive and animated features. Users can now animate streams of pictures using \AnimateStreamOps\ and \AnimateToStreamOps\ (with frame-rate control), export animations to files via \AnimationWriterSyntax\, and handle mouse events through \MouseClickSyntax\, \MouseMoveSyntax\, and \MouseOverSyntax\. Additionally, \RedrawSyntax\ provides a way to trigger redraws, and \InterpolationSyntax\ adds helpers for creating interpolations.

interact/shared/src/main/scala/doodle/interact/syntax · high confidence

The algebra layer now provides platform-specific syntax extensions for loading bitmaps and exporting images. On the JVM, users can load bitmaps synchronously via \loadUnsafe\, \loadOrDefault\, and \loadOrRecover\, and export pictures to \BufferedImage\, Base64 strings, or files using dedicated writer syntax. On JavaScript, bitmap loading is available asynchronously through \loadUnsafeAsync\, \loadOrDefaultAsync\, and \loadOrRecoverAsync\, with a renderer helper for executing IO effects.

algebra/js, algebra/jvm · high confidence

The SVG algebra has been restructured into modular traits (Blend, Filter, Image, Path, Shape, Attributed, Tagged) to support new rendering features. Users can now apply CSS-style blend modes (e.g., mix-blend-mode) to images, apply image filters like Gaussian blur, box blur, edge detection, sharpening, embossing, and drop shadows, and attach custom SVG attributes or wrap drawings in HTML tags (like links). The backend also now supports embedding bitmap images via the \<image\> tag and correctly handles SVG namespaces and styling for shapes and paths.

svg/shared/src/main/scala/doodle/svg/algebra · high confidence

Users can now write animation sequences to animated GIF files. This change introduces the GifEncoder class in the java2d backend, which handles frame buffering, color quantization, and LZW encoding to produce standard animated GIF output.

java2d/src/main/java · high confidence

The initial Scala.js-based drawing example has been removed from the project. This change deletes the HTML entry points (\index-dev.html\, \index-opt.html\) and all associated Scala source files (\BoundingBox.scala\, \Image.scala\, \PathElements.scala\, \ScalaJSExample.scala\, \Scene.scala\, \Style.scala\) that defined the core image types, rendering logic, and canvas interaction for the example application.

src/main · high confidence

A new \Base.scala\ trait has been added to the \doodle.svg\ package to define common types and the \Bundle\ interface for SVG rendering. This trait establishes the foundational structure for both JVM and JavaScript SVG backends, ensuring type consistency and enabling the compiler to verify that implementations adhere to the expected module structure. It defines core types such as \Builder\, \FragT\, and \Output\, along with the \SvgResult\ type used to handle tag rendering and associated metadata like gradients and font styles.

svg/shared/src/main/scala/doodle/svg · high confidence

The JVM-specific image syntax has been refactored to integrate with the cats-effect runtime. Users generating base64 strings or writing images to files (via \base64\ and \write\/\writeToIO\ methods) must now provide an \IORuntime\ instance via implicit resolution. This change aligns the image output operations with the project's migration to fs2 and Scala 3, ensuring that side-effecting operations are properly managed within the effect system rather than being executed synchronously without runtime context.

image/jvm/src/main/scala/doodle/image/syntax · high confidence

The Java2D REPL now uses a default frame configuration that sets the blocking behavior to DoNotBlock. This means that when rendering images in the REPL, the interpreter will not wait for the window to close before continuing, allowing for a more interactive and non-blocking workflow.

java2d/src/main/scala/doodle/java2d/repl · high confidence

The Java2D backend now uses a new \reified\ algebra package to handle rendering operations. This change introduces a \GraphicsContext\ trait that defines methods for drawing rectangles, circles, polygons, and paths, as well as rendering text and bitmaps. New traits like \ReifiedShape\, \ReifiedPath\, \ReifiedText\, and \ReifiedBitmap\ implement the specific logic for these operations, allowing the backend to generate a list of \Reified\ instructions. This refactors how shapes, text, and images are processed and rendered in the Java2D backend.

java2d/src/main/scala/doodle/java2d/algebra/reified · high confidence

The Java2D backend in the \effect\ package has been rewritten to integrate with Cats Effect and fs2, replacing the previous synchronous or ad-hoc concurrency model. This introduces a \Canvas\ abstraction that manages a Swing window and pumps mouse and redraw events into fs2 \Topic\ streams, allowing interactive applications to react to user input via functional streams. Rendering is now handled through \Java2dRenderer\ and \Java2dAnimationRenderer\, which support both static image output (via \Java2dBufferedImageWriter\ and \Java2dWriter\ for PNG, JPG, GIF, and PDF) and animated GIF generation (\Java2dAnimationWriter\). The change also includes a new \BlockingCircularQueue\ for bounded, non-blocking event buffering and a \DefaultFrame\ implementation to standardize window configuration.

java2d/src/main/scala/doodle/java2d/effect · high confidence

The \interact\ module now provides distinct syntax traits for running animations on JavaScript and JVM platforms. In \interact/js\, the \AnimationRendererSyntax\ trait executes effects asynchronously using \unsafeRunAsync\, while \interact/jvm\ uses synchronous execution via \unsafeRunSync\. Both platforms expose these capabilities through their respective \doodle.interact.syntax\ package objects, allowing users to import and use platform-appropriate animation rendering methods.

interact/js, interact/jvm · high confidence

The project has been rebranded as 'Doodle' and is now Scala 3 only, requiring users to update their build definitions to use the \doodle\ artifact with Scala 3. The license has been updated to Apache 2.0, and the repository structure now includes dedicated configuration files for Scalafmt (v3.10.7), Scalafix, and Tailwind CSS, alongside a comprehensive .gitignore and Travis CI setup for Scala 2.12/2.13 (legacy) and Java 8.

(repo-wide) · high confidence

The SVG algebra implementation has been restructured into distinct modules (Algebra, JvmTaggedModule, Text, etc.) to improve organization and maintainability. This change introduces CSS-style blend algebra support for SVG rendering, allowing for more sophisticated visual compositing effects. The text rendering module now uses Java2D font metrics for accurate bounding box calculations, and the tagged module provides utilities for adding attributes and links to SVG elements. The algebra instance now implements Monad for the Drawing type, enabling more flexible composition of SVG operations.

svg/jvm/src/main/scala/doodle/svg/algebra · high confidence

The JavaScript-specific image syntax package has been updated to use \JsImageSyntax\ instead of the previous implementation. This change ensures that the \doodle.image.syntax.all\ and related objects now correctly extend the JS-specific syntax traits, aligning with the broader refactor to split core and algebra projects and migrate to Dotty.

image/js · high confidence

This change introduces the \ReactorSyntax\ trait and its \AbstractReactorSyntax\ base, providing extension methods on \BaseReactor\ to simplify starting animations. Users can now call \animate\, \animateWithFrame\, \animateToIO\, and \animateWithFrameToIO\ directly on reactor instances to trigger rendering loops with mouse interaction support, with the JS-specific implementation handling execution via \unsafeRunAsync\.

reactor/js, reactor/shared · medium confidence

Added golden tests for frame backgrounds, gradient strokes, layout, paths, and text; Added initial test suite for SVG rendering effects; Added property-based and unit tests for core geometry, color, and transformation types; Added property-based tests for animation interpolation and transducer utilities; Added property-based tests for easing functions; Added property-based tests for the generic algebra; Added test algebra for reified drawing primitives; Added test coverage for SVG blend modes, filters, and bitmap loading; Added test infrastructure for distance metrics and arbitrary generators; Added test suites for Java2D backend writers and bitmap loading; Added tests for random sampling utilities; Added tests for the SVG algebra implementation.

The project now includes a \package-lock.json\ with \tailwindcss\ (v3.4.17) as a dev dependency, indicating the addition of a CSS build step. The Scala build (\build.sbt\) has been significantly refactored: it upgrades to Scala 3.3.6, removes the old Scala.js 0.5.5 and Workbench plugins, and adopts the sbt-typelevel plugin structure (evidenced by \tlBaseVersion\, \crossScalaVersions\, and \laika\ configuration). The build now defines a multi-project structure with JVM and JS platforms for modules like \core\, \algebra\, \java2d\, \svg\, etc., and uses a centralized \Dependencies\ object for library management.

(dependencies) · high confidence

This change introduces the initial build setup for the Creative Scala project, defining the core library dependencies (such as Cats, Cats Effect, and fs2) and test frameworks (Munit) in a new Dependencies.scala file. It also configures essential SBT plugins for Scala.js, formatting, and documentation, while upgrading the SBT version from 0.13.5 to 1.11.7.

project · high confidence

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

• First survey — no prior run to compare against. CAI 66.

• Code Health 96
• Architecture 100
• Maturity 51
• Readiness 74
• Security 77

• 300 commits — 289 feature/other, 11 fixes

• (root) — 84 commits
• docs/src — 65 commits
• core/shared — 18 commits
• examples/js — 17 commits
• java2d/src — 17 commits
• canvas/src — 13 commits
• svg/shared — 11 commits
• algebra/shared — 9 commits
• image/shared — 9 commits
• (repo) — 8 commits
• .github/workflows — 8 commits
• project/Dependencies.scala — 8 commits
• project/plugins.sbt — 8 commits
• core/jvm — 6 commits
• golden/src — 4 commits
• reactor/shared — 4 commits
• project/build.properties — 3 commits
• svg/js — 3 commits
• .vscode/settings.json — 2 commits
• algebra/js — 1 commit

• fix: Fix Canvas backend rectangle rendering
• fix: Fix arcs when angle is zero or less
• fix: Fix broken link
• fix: Fix compilation error in docs
• fix: Fix styling of SVG text
• fix: Fix warning: discarded non-Unit value of type Boolean
• fix: Merge pull request #156 from VOSID8/bug-image
• fix: Minor fix
• fix: Simplify Reactor implementation and fix SVG (#214)
• fix: fix: unused symbol error, ReifiedPath imports
• fix: fixed monospaced fonts
• change: 0.28.0 Release
• change: 0.32.0 release
• change: A bit more on naming conventions
• change: A bit more on the steps for implementing a backend
• change: Actually add the documentation for Size
• change: Add LoadBitmap algebra implementation for Canvas backend (#202)
• change: Add ScalaDoc comments in Writer effects
• change: Add ToPicture instances for OpenPath and ClosedPath (#221)
• change: Add arc paths
• …and 280 more

• 0 containers · 1 bounded contexts · 0 dependency edges (baseline)

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

creativescala/doodle 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.