Ink Custom Brush Builder
Android (Google)OfficialCreated by Google LLCDistributed by Android (Google)
- Skill
- Tool integration
- Software development
- Apache-2.0
- No issues found
AutoGineer summary
Written by AutoGineer from the skill’s own files, not by the author
The ink-custom-brush-builder skill provides a structured approach to creating programmatic custom brushes for Android applications utilizing the Jetpack Ink library (version 1.1.0-alpha03 and higher). It enables developers to define complex brush behaviors, multi-coat layers, and custom textures using Kotlin constructors rather than manual protocol buffer builders. The skill covers the entire brush hierarchy, including BrushFamily, BrushCoat, BrushTip, BrushPaint, and BrushBehavior node graphs, ensuring developers can implement responsive, high-fidelity drawing tools with features like pressure, tilt, and speed sensitivity.
What it does
- Generates complete Kotlin implementations for BrushFamily, BrushCoat, BrushTip, BrushPaint, and BrushBehavior.
- Configures dynamic stylus and touch responses using BrushBehavior node graphs.
- Applies tiling or particle stamping textures to brushes.
- Sets up input smoothing via SlidingWindowModel.
- Provides guidance on encoding and decoding custom BrushFamily definitions.
- Ensures correct dependency versions for Jetpack Ink libraries.
When to use it
- When you need to create custom brush styles beyond the provided stock brushes.
- When implementing brushes that respond dynamically to stylus pressure, tilt, or speed.
- When building multi-coat layered brushes with specific texture or color functions.
- When you need to serialize and deserialize custom brush definitions.
- When configuring specific input smoothing for drawing strokes.
Advantages
- Uses public Kotlin constructors for type-safe brush definition.
- Enables complex, organic stroke behaviors through procedural noise and response nodes.
- Supports advanced texture mapping without manual bitmap shader implementation.
- Provides a consistent, documented workflow for brush structure and behavior.
- Avoids common antipatterns like manual Bézier smoothing or raw proto builders.
Usage examples
- “How do I create a custom pressure-sensitive pen brush?”
- The agent will provide a Kotlin code snippet using BrushFamily, BrushCoat, and a BrushBehavior node graph that maps NORMALIZED_PRESSURE to SIZE_MULTIPLIER.
- “Help me add a grain texture to my custom brush.”
- The agent will guide you through implementing a BrushPaint.TilingTexture, identifying the necessary drawable resource, and registering it in the TextureBitmapStore.
Install
Download the skill as a ZIP:
https://autogineer.com/agent-skills/android/ink-custom-brush-builder/downloadUnzip it into the cross-client skills folder of your project:
mkdir -p .agents/skills && unzip ink-custom-brush-builder.zip -d .agents/skills
Documentation by Google LLC
Custom brushes in the Android Ink API are built around the BrushFamily
hierarchy:
BrushFamily
├── InputModel (BrushFamily.InputModel.SlidingWindowModel or PASSTHROUGH_MODEL)
└── BrushCoat[] (one or more rendering layers)
├── BrushTip (shape: scaleX, scaleY, cornerRounding, rotationDegrees, slantDegrees, pinch)
│ └── BrushBehavior[] (dynamic response to stylus or touch input)
│ └── Tree: TargetNode(input = [Operators](input = SourceNode))
└── BrushPaint (visual appearance)
├── SelfOverlap (ANY, ACCUMULATE, or DISCARD)
├── TextureLayer[] (BrushPaint.TilingTexture or BrushPaint.StampingTexture)
└── BrushPaint.ColorFunction[] (OpacityMultiplier or ReplaceColor)Create a Brush by combining a custom BrushFamily with a Compose Color,
size, and epsilon:
val brush = Brush.createWithComposeColor(
family = myCustomFamily,
color = Color.Black,
size = 10f,
epsilon = 0.1f,
)<br />
Version and experimental API requirements :
Requires
androidx.ink1.1.0-alpha03and higher : In1.0.0(Stable) and1.1.0-alpha01-alpha02,BrushFamily(...),BrushCoat,BrushTip,BrushPaint,BrushBehavior, andandroidx.ink.brush.behavior.*nodes were@RestrictTo(LIBRARY_GROUP)(in1.0.0stable, custom brushes can only be loaded from binary proto streams usingBrushFamily.decode). Starting in1.1.0-alpha03and higher , programmatic custom brush constructors graduated to public API (BrushPaint.TilingTexture,BrushPaint.StampingTexture,BrushPaint.ColorFunction,BrushFamily.InputModel.SlidingWindowModel, and all behavior nodes).No
@OptInrequired in1.1.0-alpha03and higher : All public custom brush classes andink-storageBrushFamilyserialization APIs (BrushFamily.encodeanddecode,AndroidBrushFamilySerialization,BrushFamilyDecodeCallback) are unannotated in1.1.0-alpha03and higher (ExperimentalInkCustomBrushApiis@RestrictTo(LIBRARY_GROUP)in1.1.0-alpha05and higher, and is only required onBrushFamilyserialization in1.0.0stable).
Workflow and task routing
Follow these conditional instructions based on the requested custom brush task:
Step 1 (Dependencies) : When setting up an Android project for programmatic custom brushes, ask user permission before editing build files and verify that
androidx.ink:ink-brush,androidx.ink:ink-brush-compose,androidx.ink:ink-storage, andandroidx.ink:ink-nativeloaderuse version1.1.0-alpha03or higher ingradle/libs.versions.tomlandapp/build.gradle.kts.Step 2 (Hierarchy, tip shape, paint, and input smoothing) : When defining
BrushFamilyand multi-coatBrushCoatlayers, configuringBrushTipgeometry (scaleX,scaleY,cornerRounding,rotationDegrees,slantDegrees,pinch), settingBrushPaintproperties (SelfOverlap,ColorFunction), or smoothing stroke input withBrushFamily.InputModel.SlidingWindowModel, you MUST follow brush-structure.md. For baselineBrushcreation or1.0.0resource loading, review Brush APIs.Step 3 (Dynamic stylus and touch behaviors) : When making a brush respond dynamically to stylus pressure, tilt, speed, direction, or procedural noise using
BrushBehaviornode trees (SourceNode,DampingNode,NoiseNode,ResponseNode,TargetNode,PolarTargetNode), you MUST follow brush-behaviors.md.Step 4 (Textures and serialization) : When adding
BrushPaint.TilingTextureorBrushPaint.StampingTexturelayers, implementingTextureBitmapStore, or encoding and decoding customBrushFamilydefinitions (BrushFamily.encodeanddecode,AndroidBrushFamilySerialization,BrushFamilyDecodeCallback), you MUST follow textures-and-serialization.md. Inform the user which texture image files (such asapp/src/main/res/drawable-nodpi/pencil_grain.png) to add to their project and register inTextureBitmapStore.Step 5 (Complete brush recipes) : When building a complete pressure pen, calligraphy nib, shading pencil, watercolor wash, or multi-coat shadow brush from scratch, start from the copy-ready implementations in examples.md.
Compose drawing surface, eraser, or persistence : For Compose drawing surface setup,
InProgressStrokeswet and dry rendering, geometry-based erasing, or Room stroke persistence, suggest theink-app-builderskill.
Antipatterns
NEVER use raw
ink.proto.*builders to construct brushes---always use the public Kotlin constructors (BrushFamily,BrushCoat,BrushTip,BrushPaint,BrushBehaviorfromandroidx.ink.brush.*).NEVER manually scale stroke width in a touch listener for pressure or tilt sensitivity---use
BrushBehaviormappingSourceNode.Source.NORMALIZED_PRESSUREorTILT_IN_RADIANStoTargetNode.Target.SIZE_MULTIPLIERorWIDTH_MULTIPLIER.NEVER use manual
Canvasbitmap stamping orBitmapShaderfor textured brushes---useBrushPaint.TilingTextureorBrushPaint.StampingTexturewith aTextureBitmapStore.NEVER use
BlendMode.SRC_OVERon the final (or only)TextureLayer---useBlendMode.MODULATE,DST_IN,DST_OUT,SRC_ATOP, orSRC_INso edge anti-aliasing andOPACITY_MULTIPLIERbehaviors aren't overridden.NEVER serialize
BrushFamilyas JSON, Gson, Moshi, orParcelable---always useBrushFamily.encodeandBrushFamily.decodeorAndroidBrushFamilySerializationfromandroidx.ink.storage.NEVER implement manual Bézier (
quadTo,cubicTo) smoothing ---configureBrushFamily.InputModel.SlidingWindowModelfor input smoothing andDampingNodefor behavior smoothing.NEVER use
Random.nextFloatin draw loops for organic stroke wobble---attach aNoiseNodevaried over stroke distance inBrushBehavior.
Files
- ATTRIBUTION.mdAdded by AutoGineer1009 B
- LICENSELicence file added by AutoGineer11.1 KiB
- SKILL.md7.2 KiB
- references/android/develop/ui/compose/touch-input/stylus-input/ink-api-brush-apis.md5.0 KiB
- references/brush-behaviors.md10.8 KiB
- references/brush-structure.md9.9 KiB
- references/examples.md11.8 KiB
- references/textures-and-serialization.md7.6 KiB
references/android/develop/ui/compose/touch-input/stylus-input/ink-api-brush-apis.md
The Brush APIs provide you with the tools to
define the visual style of your strokes. You can create brushes with different
colors, sizes, and families to achieve a variety of looks.
Android skills
Create custom Ink brushes
Use the ink-custom-brush-builder Android skill to design custom BrushFamily styles in Jetpack Compose with custom tips, dynamic behaviors, textures, and coats. To install the skill from the Android CLI, run:
android skills add ink-custom-brush-builder<br />
Create a brush
To create a brush, use the Compose Brush
companion methods with named arguments such as
Brush.Companion.createWithComposeColor.
This class lets you set the following properties:
family: The style of the brush, analogous to a typeface or font in text. SeeStockBrushesfor availableBrushFamilyvalues.color: The color of the brush. You can set the color using aColorLong.size: The overall thickness of strokes created with the brush.epsilon: The smallest distance for which two points should be considered visually distinct for stroke generation geometry purposes. The ratio of epsilon and stroke points controls how much a stroke can be zoomed in on without artifacts, at the cost of memory. A good starting point for stroke units is 1 px, and a good starting point for epsilon is 0.1. Higher epsilon values use less memory but allow for less zoom before triangle artifacts appear. Experiment to find the right value for your use case.
val brush = Brush.createWithComposeColor(
family = StockBrushes.pressurePen(),
color = Color.Black,
size = 5F,
epsilon = 0.1F
)<br />
Modify brush properties
You can create a copy of an existing brush using the
copyWithComposeColor() method, which lets you
change any of the brush's properties.
val redBrush = Brush.createWithComposeColor(
family = StockBrushes.pressurePen(),
color = Color.Red,
size = 5F,
epsilon = 0.1F
)
val blueBrush = redBrush.copyWithComposeColor(color = Color.Blue)<br />
Custom Brushes
While StockBrushes provides a versatile set of
common brushes, Ink API also offers an advanced path for creating entirely new
brush behaviors for unique artistic effects or to replicate specific existing
brushes for backward compatibility.
A custom BrushFamily is loaded from its serialized format. The required format
is the gzipped binary encoding of the
BrushFamily protocol buffer. This lets you load and use
custom brush files today. Once deserialized, the custom BrushFamily can be
used to create a new Brush with a specific color and size, just like any of
the StockBrushes families.
[!NOTE] Note: This interface is experimental and is subject to change.
class CustomBrushes(val context: Context) {
companion object {
private const val TAG = "CustomBrushes"
}
val brushes by lazy { loadCustomBrushes() }
@OptIn(ExperimentalInkCustomBrushApi::class)
private fun loadCustomBrushes(): List<CustomBrush> {
val brushFiles = mapOf(
"Calligraphy" to (R.raw.calligraphy to R.drawable.draw_24px),
"Flag Banner" to (R.raw.flag_banner to R.drawable.flag_24px),
"Graffiti" to (R.raw.graffiti to R.drawable.format_paint_24px),
// ...
)
val loadedBrushes = brushFiles.mapNotNull { (name, pair) ->
val (resourceId, icon) = pair
val brushFamily = context.resources.openRawResource(resourceId).use { inputStream ->
BrushFamily.decode(inputStream)
}
CustomBrush(name, icon, brushFamily)
}
return loadedBrushes
}
}
data class CustomBrush(
val name: String,
val icon: Int,
val brushFamily: BrushFamily
)<br />
Requirements and compatibility
Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta
“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.
Needs: Needs Node.js
Security
No issues found by our static scan· No issues found
A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.
Attribution and licence
- Created by
- Google LLC
- Publisher
- Android (Google) (Official)
- Distributed by
- Android (Google)
- Source
- android/skills · jetpack-compose/ink/ink-custom-brush-builder · commit bf68e2d
- Licence
- Apache License 2.0 (redistribution allowed)
- LICENSE (added by AutoGineer from LICENSE.txt)
- ATTRIBUTION.md (written by AutoGineer)
- Synced
AutoGineer is not affiliated with or endorsed by Google LLC or Android (Google).
Download ZIP
The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download ink-custom-brush-builder.zip