- Notifications
You must be signed in to change notification settings - Fork0
Markdown renderer for Kotlin Multiplatform Projects (Android, iOS, Desktop), using Compose.
License
Goooler/multiplatform-markdown-renderer
Folders and files
| Name | Name | Last commit message | Last commit date | |
|---|---|---|---|---|
Repository files navigation
... a Kotlin Multiplatform Markdown Renderer. (Android, Desktop, ...) powered by Compose Multiplatform
What's included 🚀 •Setup 🛠️ •Usage 🛠️ •License 📓
- Super simple setup
- Cross-platform ready
- Lightweight
Multiplatform
For multiplatform projects specify this single dependency:
dependencies { implementation("com.mikepenz:multiplatform-markdown-renderer:${version}")// Offers Material 2 defaults for Material 2 themed apps (com.mikepenz.markdown.m2.Markdown) implementation("com.mikepenz:multiplatform-markdown-renderer-m2:${version}")// Offers Material 3 defaults for Material 3 themed apps (com.mikepenz.markdown.m3.Markdown) implementation("com.mikepenz:multiplatform-markdown-renderer-m3:${version}")}JVM
To use the library on JVM, you have to include:
dependencies { implementation("com.mikepenz:multiplatform-markdown-renderer-jvm:${version}")}Android
For Android a special dependency is available:
dependencies { implementation("com.mikepenz:multiplatform-markdown-renderer-android:${version}")}Tip
Since 0.13.0 the core library does not depend on a Material theme anymore. Include the-m2or-m3 module to getaccess to the defaults.
val markdown="""### What's included 🚀- Super simple setup- Cross-platform ready- Lightweight""".trimIndent()//Markdown(markdown)
Advanced Usage
val markdownState= rememberMarkdownState(markdown)Markdown(markdownState)
[!NOTE]
This approach is also advised if you want to retain scroll position even when navigating awaySee:mikepenz#374Retaining state in the VM ensures parsing will not have to be done again, and the component can beimmediately filled.
// In the VM setup the flow to parse the markdownval markdownFlow= parseMarkdownFlow("# Markdown") .stateIn(lifecycleScope,SharingStarted.Eagerly,State.Loading())// In the Composable use the flowval state by markdownFlow.collectAsStateWithLifecycle()Markdown(state)
The library offers the ability to modify different behaviour when rendering the markdown.
Markdown( content, colors= markdownColors(text=Color.Red), typography= markdownTypography(h1=MaterialTheme.typography.body1))
By default, theMarkdownText animates size changes (if images are loaded).
Markdown( content, animations= markdownAnimations( animateTextSize= {this/** No animation*/ } ),)
Starting with 0.16.0 the library includes supportforextended-spans.
The library was integrated to make it multiplatform-compatible.All credits for its functionality go toSaket Narayan.
It is not enabled by default, however you can enable it quickly by configuring theextendedSpansfor yourMarkdown composeable.Define theExtendedSpans you want to apply (including optionally your own custom ones) and returnit.
Markdown( content, extendedSpans= markdownExtendedSpans {val animator= rememberSquigglyUnderlineAnimator() remember {ExtendedSpans(RoundedCornerSpanPainter(),SquigglyUnderlineSpanPainter(animator= animator) ) } })
The library already handles a significant amount of different tokens, however not all. To allowspecial integrations expand this, you can pass in a customannotator to theMarkdowncomposeable. Thisannotator allows you to customize existing handled tokens, but also add newones.
Markdown( content, annotator= markdownAnnotator { content, child->if (child.type==GFMElementTypes.STRIKETHROUGH) { append("Replaced you :)")true// return true to consume this ASTNode child }elsefalse })
// Use the bullet list symbol from the original markdownCompositionLocalProvider(LocalBulletListHandler provides {"$it" }) {Markdown(content)}// Replace the ordered list symbol with `A.)` instead.CompositionLocalProvider(LocalOrderedListHandler provides {"A.)" }) {Markdown(content,Modifier.fillMaxSize().padding(16.dp).verticalScroll(scrollState))}
Since v0.9.0 it is possible to provide custom components, instead of the default ones.This can be done by providing the componentsMarkdownComponents to theMarkdown composable.
Use themarkdownComponents() to keep defaults for non overwritten components.
TheMarkdownComponent will expose access tothecontent: String,node: ASTNode,typography: MarkdownTypography,offering full flexibility.
// Simple adjusted paragraph with different Modifier.val customParagraphComponent:MarkdownComponent= {MarkdownParagraph(it.content, it.node,Modifier.align(Alignment.End))}// Full custom paragraph exampleval customParagraphComponent:MarkdownComponent= {// build a styled paragraph. (util function provided by the library)val styledText= buildAnnotatedString { pushStyle(LocalMarkdownTypography.current.paragraph.toSpanStyle()) buildMarkdownAnnotatedString(content, it.node) pop() }// define the `Text` composableText( styledText, modifier=Modifier.align(Alignment.End), textAlign=TextAlign.End )}// Define the `Markdown` composable and pass in the custom paragraph componentMarkdown( content, components= markdownComponents( paragraph= customParagraphComponent ))
Another example to of a custom component is changing the rendering of an unordered list.
// Define a custom component for rendering unordered list items in Markdownval customUnorderedListComponent:MarkdownComponent= {// Use the MarkdownListItems composable to render the list itemsMarkdownListItems(it.content, it.node, level=0) { startNumber, index, child->// Render an icon for the bullet point with a green tintIcon( imageVector= icon, tint=Color.Green, contentDescription=null, modifier=Modifier.size(20.dp), ) }}// Define the `Markdown` composable and pass in the custom unorderedList componentMarkdown( content, components= markdownComponents( unorderedList= customUnorderedListComponent ))
Starting with 0.30.0, the library includes support for rendering tables in markdown. TheMarkdowncomposable will automatically handle table elements in your markdown content.
val markdown="""| Header 1 | Header 2 ||----------|----------|| Cell 1 | Cell 2 || Cell 3 | Cell 4 |""".trimIndent()Markdown(markdown)
To configure image loading, the library offers different implementations, to offer great flexibilityfor the respective integration.After adding the dependency, the chosen image transformer implementation has to be passed to theMarkdown API.
Note
Please refer to the official documentation for the specific image loading integration you areusing (e.g., coil3) on how to adjust itsbehavior.
// Offers coil3 (Coil3ImageTransformerImpl)implementation("com.mikepenz:multiplatform-markdown-renderer-coil3:${version}")
Markdown(MARKDOWN, imageTransformer=Coil3ImageTransformerImpl,)
// Offers coil2 (Coil2ImageTransformerImpl)implementation("com.mikepenz:multiplatform-markdown-renderer-coil2:${version}")
Markdown(MARKDOWN, imageTransformer=Coil2ImageTransformerImpl,)
The library (introduced with 0.27.0) offers optional support for syntax highlighting viatheHighlights project.This support is not included in the core, and can be enabled by adding themultiplatform-markdown-renderer-codedependency.
implementation("com.mikepenz:multiplatform-markdown-renderer-code:${version}")Once added, theMarkdown has to be configured to use the alternative code highlighter.
// Use default color schemeMarkdown(MARKDOWN, components= markdownComponents( codeBlock= highlightedCodeBlock, codeFence= highlightedCodeFence, ))// ADVANCED: Customize Highlights library by defining different themeval isDarkTheme= isSystemInDarkTheme()val highlightsBuilder= remember(isDarkTheme) {Highlights.Builder().theme(SyntaxThemes.atom(darkMode= isDarkTheme))}Markdown(MARKDOWN, components= markdownComponents( codeBlock= {MarkdownHighlightedCodeBlock( content= it.content, node= it.node, highlights= highlightsBuilder ) }, codeFence= {MarkdownHighlightedCodeFence( content= it.content, node= it.node, highlights= highlightsBuilder ) }, ))
This project uses JetBrainsmarkdown MultiplatformMarkdown processor asdependency to parse the markdown content.
This free, open source software was also made possible by a group of volunteers that put many hoursof hard work intoit. See theCONTRIBUTORS.md file for details.
Big thanks toErik Hellman and his awesome articleonRendering Markdown with Jetpack Compose,and the related sourceMarkdownComposer.
Also huge thanks toSaket Narayan for his great work ontheextended-spans project. Ported into this project tomake it multiplatform.
Copyright for portions of the code are held by [Erik Hellman, 2020] as part ofprojectMarkdownComposer under the MIT license.All other copyrightfor project multiplatform-markdown-renderer are held by [Mike Penz, 2023] under the Apache License,Version 2.0.
Copyright 2025 Mike PenzLicensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.About
Markdown renderer for Kotlin Multiplatform Projects (Android, iOS, Desktop), using Compose.
Resources
License
Security policy
Uh oh!
There was an error while loading.Please reload this page.
Stars
Watchers
Forks
Releases
Packages0
Languages
- Kotlin99.1%
- Ruby0.9%