All notable changes to this project will be documented in this file.
The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.
Paragraph.getRectsForPlaceholdershad been returning a list of Float32Arrays upon which a property ‘direction’ had been monkey-patched (this was undocumented). They now return an object
CanvasKit.MakeOnScreenGLSurfaceallows providing a cached sample count and stencil value to avoid repeated lookups on Surface creation.
MakeLumaColorFilter factory method.
ColorFilter.MakeBlendsupports float colors under the hood and takes an optional colorspace.
@webgpu/typesversions, used for testing index.d.ts types.
Image.readPixelsshould work on
Images created with
ImageFilter.MakeDisplacementMapis not behaving as expected in certain circumstances.
MakeLazyImageFromTextureSourceall take an optional
srcIsPremulto specify if their source data has Premultiplied alpha. This avoids double multiplying alpha in certain cases.
CanvasKit.MakeGPUTextureSurfacewhich are compatible with WebGPU
CanvasKit.MakeCanvasSurfaceis now deprecated. Clients should specify a backend target explicitly using
CanvasKit.MakeGrContextis now deprecated. Clients should use
RuntimeEffect.makeShaderWithChildrencan properly accept uniform data as MallocObj or derived TypedArrays without incorrectly freeing the uniform data.
SkRuntimeEffect.makeShaderWithChildrenno longer accept an
isOpaqueparameter. These functions will now make a best effort to determine if your shader always produces opaque output, and optimize accordingly. If you definitely want your shader to produce opaque output, do so in the shader's SkSL code.
Surface.updateTextureFromSourceprevents flickering on some platforms by re-using the texture for a given
Imageinstead of needing to always create a new one via
ParagraphBuilder.resetallows re-use of the underlying memory.
CanvasKit.MakeWebGLCanvasSurfaceor calling any factory that does not take a color space will now create a surface with a color space of
Surface.makeImageFromTextureSourceshould not cause issues with Mipmaps or other places where Skia needs to create textures (skbug.com/12797)
CanvasKit.MakeRenderTargetcorrectly takes 2 or 3 params, as per the documentation.
CanvasKit.MakeOnScreenGLSurfaceand other gpu surface constructors correctly adjust the underlying WebGL context, avoiding corruption and mismatched textures (https://github.com/flutter/flutter/issues/95259).
Canvas.drawPatchtreat the default blend mode differently. See https://bugs.chromium.org/p/skia/issues/detail?id=12662.
Canvas.findMarkedCTMhave been removed. They were effectively no-ops.
measureTextto Canvas2D emulation layer. For accurate numbers, clients should use a real shaping library, like SkParagraph.
AnimatedImage.currentFrameDurationhas been added, as well as some clarifying documentation.
CanvasKit.MakeLazyImageFromTextureSource, which is similar to
Surface.makeImageFromTextureSource, but can be re-used across different WebGL contexts.
Surface.makeImageFromTextureSourcenow takes an optional ImageInfo or PartialImageInfo instead of optional width and height. Sensible defaults will be used if not supplied.
Surfacemethods would not properly switch to the right WebGL context.
INVALID_ENUM: enable: invalid capabilityshould be reduced/eliminated.
FontMgr.RefDefaulthave been removed in favor of
make debug, and variants put the output in a different location (./build).
Surface.drawOnceare properly documented.
Surface.openGLversion- these had been undocumented and are no longer exposed.
CanvasKit.currentContext. Existing calls can be deleted.
Canvas.drawImage*calls are correctly documented as accepting an optional
Path.makeAsWindinghas been added to convert paths with an EvenOdd FillType to the equivalent area using the Winding FillType.
Paint.getBlendMode()has been removed.
Canvas.drawImageAtCurrentFrame()has been removed.
objectwith actual types, including
Typeface.MakeFreeTypeFaceFromDataas a more convenient way to create a Typeface from the bytes of a .ttf, .woff, or .woff2 file.
Typeface.getGlyphIDs- provides the same functionality as
Font.getGlyphIDshad the wrong type for the third argument. It is now correctly a Uint16Array.
FontMgr.MakeTypefaceFromDatawill be removed in favor of
FontMgr.RefDefaultwill be removed in an upcoming version. It's only real use was for
Surface.makeImageFromTextureSourceas easy ways to provide CanvasKit with a WebGL texture and interact with WebGL texture sources (e.g. <video>)
Path.toCmds()returns a flattened Float32Array instead of a 2D Array.
Canvaskit.Path.MakeFromCmdsno longer accepts a 2D Array. Inputs must be flattened, but can be an array, a TypedArray, or a MallocObj.
CanvasKit.*Builderhave all been removed. Clients should use Malloc instead.
CanvasKit.Shader.MakeLerp, the same effect can be easily generated with
Canvas.flush, which had been previously deprecated.
Surface.flushis the preferred method.
AnimatedImage.getCurrentFrame, which had been previously deprecated.
AnimatedImage.makeImageAtCurrentFrameis the replacement, which behaves exactly the same.
CanvasKit.RuntimeEffectnow supports integer uniforms in the SkSL. These are still passed to
RuntimeEffect.makeShaderas floats (like all other uniforms), and will be converted to integers internally, to match the expectations of the shader.
ParagraphStylenow accepts textHeightBehavior.
Picture.saveAsFile(), in favor of
Picture.serialize()where clients can control how to store/encode the bytes.
CanvasKit.rt_effectto test if the RuntimeEffect code was compiled in.
ShapedTexttype has been removed. Clients who want ShapedText should use the Paragraph APIs.
Font.measureText, which had been previously deprecated. Clients should use either Paragraph APIs or
Font.getGlyphWidthsinstead (the latter does no shaping).
Font.getWidths, which had been previously deprecated. Clients should use
CanvasKit.getDataByteshas been removed, as has the Data type. The 2 APIS that returned Data now return Uint8Array containing the bytes directly. These are
SkPicture.serialize. These APIs return null if the encoding or serialization failed.
Image.encodeToDataWithFormatwas incorrectly documented as its own thing.
getShadowLocalBounds()to estimate the bounds of the shadows drawn by
CanvasKit.RuntimeEffect.Makenow takes an optional callback function that will be called with any compilation error.
CanvasKit.RuntimeEffectnow exposes uniforms. The number, dimensions, and name of each uniform can be queried, using
RuntimeEffect.getUniformName. The total number of floats across all uniforms (that must be passed to
RuntimeEffect.makeShader) can be queried with
Particle. For example, instead of
ParticleEffect.getParticleUniform, there is now just:
SkottieAnimation.size()now return a TypedArray instead of a normal array. Additionally, they take an optional parameter to allow the result to be copied into that provided TypedArray instead of a new one being allocated.
Canvas.drawShadow()now accepts zPlaneParams and lightPos as Malloc'ed and regular Float32Arrays.
getShadowLocalBounds()does as well.
ContourMeasure.getPosTanreturns a Float32Array instead of a normal array. Additionally, this method takes an optional parameter to allow the result to be copied into that provided Float32Array instead of a new one being allocated.
SkottieAnimation.size()was incorrectly returning an object. It now returns a TypedArray of length 2 (w, h).
Canvas.drawAtlas, These rely on the Paint's FilterQuality, which is going away. Pass sampling options explicitly.
PathMeasure, which was deprecated and replaced with
Canvas.drawImageRectOptionsto replace functionality that previously required FilterQuality.
Canvas.drawImageNinenow takes a required FilterMode (the Paint still is optional).
CanvasKit.deleteContext()for deleting WebGL contexts when done with them, resizing, etc.
Image.makeCopyWithDefaultMipmaps()for use with
Image.makeShaderOptions; necessary if choosing a
MipmapModethat is not
Path.addPoly()no longer accepts a 2d array of points, but a flattened 1d array.
MakeVertices()no longer accepts 2d arrays of points or texture coordinates, but flattened 1d arrays in both places.
Image.makeShaderhave been removed. The new way to specify interpolation settings is with the newly added
Image.makeShaderCubicis a replacement for high quality;
Image.makeShaderOptionsis for medium/low.
MakeImageis now documented in the Typescript types (index.d.ts). The parameters have been streamlined to align with other, similar APIs.
MakeAnimatedImageFromEncodedrespects Exif metadata.
MakeImageFromEncodedalready did so (and continues to do so).
Canvas.drawPointscorrectly takes a flattened Array or TypedArray of points (as the documentation says), not a 2D array.
MakeTurbulencehave been added to
MakeRasterDirectSurfacefor giving the user direct access to drawn pixels.
Canvas.saveLayerPaintas an experimental, undocumented “fast path” if one only needs to pass the paint.
CanvasKit.MakePathFromSVGStringwas renamed to
CanvasKit.MakePathFromOpwas renamed to
Image.readPixelshas been reworked to more accurately reflect the C++ backend and each other. bytesPerRow is now a required parameter. They take an ImageInfo object to specify the output format. Additionally they take an optional malloc'd object as the last parameter. If provided, the data will be copied into there instead of allocating a new buffer.
...Lerphave been renamed to
...MakeLerpto align with naming conventions. The old names will be removed in an upcoming release.
CanvasKit.MakePathFromCmds; Was deprecated in favor of
new CanvasKit.Path(path)in favor of existing
measureTextfrom the CanvasContext2D emulation layer due to deprecation of measureText.
Font.getWidthsin favor of
Font.measureTextin favor of the Paragraph APIs (which actually do shaping).
CanvasKit.GrContextwas renamed to
new CanvasKit.Paint(). See
./types/index.d.tsfor all the new names.
Surface.captureFrameAsSkPicture; it was deprecated previously.
CanvasKit.MakeTwoPointConicalGradientShader; these were deprecated previously and have replacements like
Canvas.concat44; it was deprecated previously, just use
CanvasKit.XYWHRectnor are accepted as JS objects. Instead, the format is 4 floats in either an array, a Float32Array or a piece of memory returned by CanvasKit.Malloc. These floats are the left, top, right, bottom numbers of the rectangle.
CanvasKit.RRectXYnor are accepted as JS objects. Instead, the format is 12 floats in either an array, a Float32Array or a piece of memory returned by CanvasKit.Malloc. The first 4 floats are the left, top, right, bottom numbers of the rectangle and then 4 sets of points starting in the upper left corner and going clockwise. This change allows for faster transfer between JS and WASM code.
SkPath.addRoundRecthas been replaced with
SkPath.addRRect. The same functionality can be had with the
SkPath.addRectno longer accepts 4 floats as separate arguments. It only accepts an SkRect (an array/Float32Array of 4 floats) and an optional boolean for determining clockwise or counter-clockwise directionality.
SkCanvas.saveLayerarguments is slightly different (more consistent). It is now
paint, bounds, backdrop, flags
mainused with SkSL passed to
CanvasKit.SkRuntimeEffect.Makehas changed. There is no longer an
inout half4 colorparameter, effects must return their color instead. Valid signatures are now
half4 main(float2 coord).
SkVertices.boundsnow take an optional argument. If a Float32Array with length 4 or greater is provided, the bounds will be copied into this array instead of allocating a new one.
SkCanvas.drawAnimatedImagehas been removed in favor of calling
SkTextBlob.MakeFromRSXformalso accepts a (possibly Malloc'd) Float32Array of RSXforms ( see SkRSXform for more.)
SkCanvas.drawRoundRecthas been removed in favor of
SkCanvas.drawRRectThe same functionality can be had with the
SkPath.arcTowhich had been deprecated in favor of
CanvasKit.XYWHiRectas helpers to create SkIRects.
SkCanvas.drawRect4fas a somewhat experimental way to have array-free APIs for clients that already have their own representation of Rect. This is experimental because we don‘t know if it’s faster/better under real-world use and because we don't want to commit to having these for all Rect APIs (and for similar types) until it has baked in a bit.
SkFont.getGlyphWidthsfor turning code points into GlyphIDs and getting the associated metrics with those glyphs. Note: glyph ids are only valid for the font of which they were requested.
SkTextBlob.MakeFromGlyphsas a way to build TextBlobs using GlyphIDs instead of code points.
CanvasKit.MallocGlyphIDsas a helper for pre-allocating space on the WASM heap for Glyph IDs.
SkAnimatedImage.makeImageAtCurrentFrame(which follows the establishing naming convention).
SkSurface.captureFrameAsSkPicturewill be removed in a future release. Callers can simply use
CanvasKit.FourFloatArrayHelperand related helpers (mostly helping with drawAtlas).
CanvasKit.Mallocis the better tool and will replace these soon.
SkPathMeasure; SkContourMeasureIter has all the same functionality and a cleaner pattern.
SkPath.computeTightBounds()works again. Like getBounds() it takes an optional argument to put the bounds into.
CanvasKit.TypefaceFontProvider, which can be used to register fonts with a font family alias. For example, “Roboto Light” may be registered with the alias “Roboto”, and it will be used when “Roboto” is used with a light font weight.
CanvasKit.ParagraphBuilder.MakeFromFontProviderto make a
CanvasKit.ParagraphBuilder.pushPaintStylewhich can be used to stroke or fill text with paints instead of simple colors.
do-whileloops in WebGL 1.0.
CanvasKit.MakeImageFromCanvasImageSourcewhich takes either an HTMLImageElement, SVGImageElement, HTMLVideoElement, HTMLCanvasElement, ImageBitmap, or OffscreenCanvas and returns an SkImage. This function is an alternative to
CanvasKit.MakeImageFromEncodedfor creating SkImages when loading and decoding images. In the future, codesize of CanvasKit may be able to be reduced by removing image codecs in wasm, if browser APIs for decoding images are used along with
CanvasKit.SkPath.addVerbsPointsWeightsfor supplying many path operations (e.g. moveTo, cubicTo) at once.
CanvasKit.mallocnow has a
subarraymethod which works exactly like the normal TypedArray version. The TypedArray which it returns is also backed by WASM memory and when passed into CanvasKit will be used w/o copying the data (just like
SkM44.setupCamerato return a 4x4 matrix which sets up a perspective view from a camera.
SkPath.arcToRotatedto replace the three overloads of
reportBackendTypeIsGPUand made it return a boolean
MakeWebGLCanvasSurfacecan now accept an optional dictionary of WebGL context attributes that can be used to override default attributes.
TextStyle.colorcan correctly be a Malloc'd Float32Array.
CanvasKit.MakePathFromCmdshas been renamed to
CanvasKit.SkPath.MakeFromCmds. The alias will be removed in an upcoming release.
SkPath.arcToSeparated into three functions.
TypeError: Cannot perform %TypedArray%.prototype.set on a neutered ArrayBuffer.
SkSurface.reportBackendTypewhich returns either ‘CPU’ or ‘GPU’.
SkSurface.imageInfowhich returns an ImageInfo object describing the size and color properties of the surface. colorSpace is added to ImageInfo everywhere it is used.
CanvasKit.Freeto explicitly clean up memory after
CanvasKit.Malloc. All memory allocated with
CanvasKit.Mallocmust be released with
CanvasKit.Freeor it will be leaked. This can improve performance by reducing the copying of data between the JS and WASM side.
SkCanvas.drawColorIntfor when clients want to avoid the overhead of allocating an array for color components and only need 8888 color.
CanvasKit.MakeCanvasSurfaceaccepts a new enum specifying one of the three color space and pixel format combinations supported by CanvasKit.
_Make*Shaderfunctions now accept a color space argument at the end. leaving it off or passing null makes it behave as it did before, defaulting to sRGB
SkPaint.setColoraccepts a new color space argument, defaulting to sRGB.
CanvasKitInit(...)now directly returns a Promise. As such,
CanvasKitInit(...).ready()has been removed.
CanvasKit.MakeCanvasSurfaceno longer accepts width/height arguments to override those on the canvas element. Use the canvas element's width/height attributes to dictate the size of the drawing area, and use CSS width/height to set the size it will appear on the page (it is rescaled after drawing when css sizing applies).
CanvasKit.Mallocwill no longer be automatically cleaned up. Clients must use
CanvasKit.Freeto release the memory.
CanvasKit.Mallocno longer directly returns a TypedArray, but an object that can produce them with toTypedArray(). This is to avoid “detached ArrayBuffer” errors: https://github.com/emscripten-core/emscripten/issues/6747
getErrorshould be disabled. This may cause a performance improvement in some scenarios.
SkCanvas.concat44has been folded into concat (which now takes 3x2, 3x3, or 4x4 matrices). It will be removed soon.
SkCanvas.saveLayercan now be called with 1 argument (the paint). In this case the current effective clip will be used, as the current rect is assumed to be null.
no_codecsto compile.sh to remove all codec encoding and decoded code. This can save over 100 kb compressed if codecs are not needed.
MakeSkDashPathEffectwill be removed soon. Calls can be replaced with
MakeLinearGradientShaderwill be removed soon. Calls can be replaced with
MakeRadialGradientShaderwill be removed soon. Calls can be replaced with
MakeTwoPointConicalGradientShaderwill be removed soon. Calls can be replaced with
MakeSkCornerPathEffectwill be removed soon. Calls can be replaced with
MakeSkDiscretePathEffectwill be removed soon. Calls can be replaced with
SkSurface.drawOncefor drawing a single frame (in addition to already existing
SkSurface.requestAnimationFramefor animation logic).
CanvasKit.parseColorStringwhich processes color strings like “#2288FF”
SkRuntimeEffect.makeShaderWithChildren, which can take in other shaders as fragmentProcessors.
GrContext.releaseResourcesAndAbandonContextto free up WebGL contexts.
SkMatrix.multiplycan now accept any number of matrix arguments, multiplying them left-to-right.
SkFontMgr.getFamilyNameto expose the parsed font names.
CanvasKit.MakeSkPictureis now exposed. SKP support is not shipped to npm builds.
force_serialize_skphas been removed since it opt-out, not opt-in.
bin/core/. It is about half the size of the “CoreWithFonts” build.
SkAnimatedImage.getCurrentFramewhich returns an SkImage.
bin/there is the “CoreWithFonts” build that contains most functionality from 0.10.0. However, we no longer ship the Skottie animation player, nor the Particles demo. Further, PathOps are removed from this build
SkPath.simplify. Clients who need any of those features are encouraged to create a custom build using
SkPicture.DEBUGONLY_saveAsFilewas accidentally included in release builds. It has been removed. Clients who need this in a release build (e.g. to file a bug report that only reproduces in release) should do a custom build with the
SkCanvas.drawAnimatedImagewill be renamed soon. Calls can be replaced with
SkContourMeasureas an alternative to
SkParagraph.getRectsForRangenow have direction with value
MakeImageproperly in the externs file and can work with
CanvasKit.Malloc, which can be used to create a TypedArray backed by the C++ WASM memory. This can save a copy in some cases (e.g. SkColorFilter.MakeMatrix). This is an advanced feature, so use it with care.
SkCanvas.saveLayernow takes 3 or 4 params to include up to bounds, paint, SkImageFilter, flags.
SkPath.rQuadTo. Like their non-relative siblings, these are chainable.
getWordBoundary, and others.
CanvasKit.MakeBlurMaskFilterwill be renamed/moved soon to
CanvasKit.SkFontMgr.FromDatawhich takes several ArrayBuffers of font data, parses them, reading the metadata (e.g. family names) and stores them into a SkFontMgr.
no_fontcompile option should strip out more dead code related to fonts.
no_embedded_fontoption now allows creating a
SkFontMgr.FromDatainstead of always having an empty one.
CanvasKit.RRectXY). Advanced users can specify the 8 individual radii, if needed.
CanvasKit.computeTonalColors(), which returns TonalColors, which has an ambient SkColor and a spot SkColor.
CanvasKit.SkColorFilterand a variety of factories.
SkPaint.setColorFilteris the only consumer of these at the moment.
.concat()and others. Primarily for use with
MakeSkVerticesuses a builder to save a copy.
SkPath.arcTois given seven arguments, it no longer turns the first four into a
SkRectautomatically, and instead uses them as
arcTo(rx, ry, xAxisRotate, useSmallArc, isCCW, x, y)(see SkPath.h for more).
GrContexthas new methods for monitoring/setting the cache limits; tweaking these may lead to better performance in some cases.
SkCanvas.drawAtlasfor efficiently drawing multiple sprites from a sprite sheet with a set of transforms, color blends, etc.
SkRectBuilderwhich increase performance by reducing the amount of malloc/free calls per frame, given that the array size is fixed.
SkSurface.captureFrameAsSkPictureis a helper function to capture an
SkPicture, which can be dumped to disk (for debugging) with
SkImage.readPixels, which returns a TypedArray of pixel values (safe to use anywhere, doesn't need a delete()).
GrGLCapssupport for WebGL - this shouldn't have any impacts on APIs or correctness, except by perhaps fixing a few bugs in various surface types.
SkImage.makeShader- removed clampUnpremul as argument.
SkTextBlob.MakeFromRSXformwhich were needed to add the helper function
SkSurface.requestAnimationFrame- wrapper around window.requestAnimationFrame that takes care of the setup/tear down required to use CanvasKit optimally. The callback has an
SkCanvasas the first parameter - callers should draw on that.
SkCanvas.flushwill be removed soon - client should only call
CanvasKit.MakeSkVertices. The previous (and current default) behavior was for this to be true; some applications may go faster if set to false.
SkCanvas.restoreToCount(int)which can be used with the output of .save() and .saveLayer().
SkCanvas.getSurface()for making compatible surfaces (typically used as a workspace and then “saved” with
CanvasKit.MakeWebGLCanvasSurfaceno longer takes a webgl context as a first arg, only a canvas or an id of a canvas. If users want to manage their own GL contexts, they should build the
MakeManagedAnimationfor supplying external assets (like images, fonts).
SkCanvas.SkTextBlob.MakeFromText()to draw text to a canvas.
CanvasKit.TextEncodingenum. For use with
SkCanvas.drawText. At compile time, one can choose between using Harfbuzz/ICU (default) or a primitive one (“primitive_shaper”) which just does line breaking. Using Harfbuzz/ICU substantially increases code size (4.3 MB to 6.4 MB).
SkCanvas.drawText()now requires an
SkFontobject for raw strings.
SkPaint.setTypeface()which should be replaced by using
CanvasKitInit().then()interface (see 0.3.1 notes)
ready()if already loaded.
MakeCanvasSurfacecan now take a canvas element directly.
MakeWebGLCanvasSurfacecan now take a WebGL context as an integer and use it directly.
CanvasKitInit(...).then()is no longer the recommended way to initialize things. It will be removed in 0.4.0. Use
CanvasKitInit(...).ready(), which returns a real Promise.
fontmgr.MakeTypefaceFromDatato load fonts.
SkPath.setVolatile. Some animations see performance improvements by setting their paths' volatility to true.
SkPath.addRectnow correctly draws counter-clockwise vs clockwise.
CanvasKit.MakeImageShaderno longer takes encoded bytes, but an
SkImage, created from
CanvasKit.MakeImageFromEncoded. Additionally, the optional parameters
localMatrixhave been exposed.
forceMoveToas additional parameters.
SkPath.strokehas a new option
precisionIt defaults to 1.0.
fontmgr.MakeTypefaceFromDatafor more font variety.
CanvasKit.initFonts()- no longer needed.
Beginning of Changelog history