Publishing one Kotlin Multiplatform library to six places: Maven Central, SPM, pub.dev, npm, PyPI, and the web
I started Nepali Date Picker to solve one problem: give Android and iOS a Bikram Sambat date picker that feels exactly like the Material 3 one. I did not plan to end up publishing the same code to six different package ecosystems. But a calendar is not an Android problem or an iOS problem. It is a Nepali problem, and Nepali dates show up on backends, in scripts, on websites, and in Python notebooks just as often as they show up in a mobile UI.
So over time the library grew a second life as a publishing exercise: one set of conversion tables, shipped everywhere a developer might need them. This is the map of how that works, what each destination actually wants from you, and the mistakes I made so you do not have to.
The one rule that made everything else possible
Before any of the publishing, there is one decision that pays for itself over and over: the calendar math lives in exactly one place, and it has zero UI dependencies.
In this project that place is the :core module. It depends only on kotlinx-datetime. No Compose, no Android, nothing that would stop it compiling for a backend or a browser. The Bikram Sambat to Gregorian conversion is table driven: a map from each BS year to the number of days in each of its twelve months. That table is the source of truth for the entire ecosystem. If it is correct in :core, every downstream target is correct.
Keeping :core Compose free took one trick worth knowing. The core data classes still want to advertise Compose stability (@Immutable, @stable) on the targets that have Compose, without dragging Compose onto the targets that do not. I declare those annotations in commonMain as @OptionalExpectation expect annotation class, and a Compose-only source set provides the actual typealias to androidx.compose.runtime.*. On a plain JVM backend or a Linux native target, the annotation simply compiles away to nothing. That is what lets one module target a strict superset of platforms while the UI module targets only the ones Compose supports.
The library ends up as three artifacts:
- :core, conversion, formatting, calendar utilities. Pure Kotlin.
- :ui, the Compose Multiplatform pickers. Depends on :core.
- :serialization, optional kotlinx-serialization support, kept separate so no serialization dependency leaks into projects that do not want it.
Everything below is just teaching a different ecosystem how to consume that core.
Destination 1: Maven Central (the Kotlin Multiplatform home)
This is the primary target and the one most KMP guides already cover, so I will keep it to what actually matters.
A multiplatform publication is not one artifact. It is a root module plus one per target (-android, -jvm, -js, -iosarm64, and so on), tied together by Gradle metadata. The Kotlin Gradle plugin generates all of it. Your job is three things: coordinates, signing, and the target list.
- Coordinates and signing. Maven Central requires a group you own (mine is io.github.shivathapaa, verified through the GitHub namespace), plus GPG-signed artifacts. The modern Central Portal flow is smoother than the old OSSRH staging dance, but budget an afternoon the first time for the account, the namespace verification, and the signing key.
- The target matrix belongs in one place. I keep target declarations and the JVM toolchain in convention plugins under build-logic, not scattered across modules. Because :core is Compose free, it targets a strict superset of :ui: :core adds linuxX64, mingwX64, wasmWasi, the watch and TV targets, and more, while :ui covers only what Compose Multiplatform supports.
- Split the artifacts on real boundaries. Splitting :core out from :ui is what makes the library usable on a server at all. A backend that only needs to convert a date should not have to pull in Compose. (When I moved from the single umbrella artifact to the split in 3.0.0, the only migration most people needed was changing the dependency coordinate from nepali-date-picker to nepali-date-picker-ui.)
Consumers add one line to commonMain and get every platform:
commonMain.dependencies {
implementation("io.github.shivathapaa:nepali-date-picker-ui:<version>")
}
Destination 2: iOS through Swift Package Manager
KMP already produces an iOS framework, but a Swift developer expects to add a package by URL in Xcode, not to reason about your Gradle output. Swift Package Manager wants a Git repository with a Package.swift that points at a binary XCFramework.
The pattern that works well: build the XCFramework from the :ui module in the main repo, then publish it through a separate, thin SPM repository (mine is Nepali-Date-Picker-SPM). That repo holds the Package.swift and a release pointing at the built framework. The separation keeps the huge binary and the SPM release tags out of the main source repo, and it gives Swift users the exact "Add package dependencies, paste URL, done" flow they expect:
import nepali_date_picker
The release workflow rewrites that Package.swift with the new asset URL and its checksum, so the manifest and the binary can never drift apart. Nobody edits it by hand.
That principle is worth pushing further than the manifest, because a thin repository still has a README, and a README states facts that go stale the moment you cut the next release. So the SPM repository now carries no prose of its own either. Its page is rendered from a template in the main repo, and every fact on it (the version, the date, both archive sizes, both checksums, the platform floors, the supported year range) is substituted from the outputs of the build that produced the release. The year range is read out of the Kotlin source that defines it rather than restated. A placeholder with no value behind it fails the release instead of publishing literal braces, which is the property that makes the whole thing trustworthy: the page cannot quietly describe a release that never happened.
Shipping a framework is not the same as shipping an API. This is the same lesson the npm section below tells, and I had to learn it twice. Kotlin/Native will happily export your module to Objective-C, but a Swift developer calling a Compose composable is not a thing. So the pickers are exposed as UIViewController factories: one function per picker, each returning a controller a SwiftUI view wraps in a UIViewControllerRepresentable. Two details that only show up once you try it:
- Kotlin default arguments do not survive the Objective-C bridge. A composable with eighteen optional parameters becomes an eighteen-argument Swift call with no defaults. The fix is a plain options object per picker (NepaliCalendarOptions, NepaliDockedOptions, and so on) that the Swift side mutates before handing it over.
- Compose cannot tell SwiftUI how tall it is. A hosted controller has no intrinsic content size, so the frame collapses or clips. Every factory takes an onHeightChange callback and the SwiftUI wrapper drives its own frame from it.
That first point has a consequence that took me a release to appreciate, and it is the one I would warn people about hardest: on the Swift side, adding a parameter with a default value is a source-breaking change. In Kotlin, giving a state factory a new initialCalendarSystem parameter with a default is purely additive; every existing call site keeps compiling. Across the bridge the default vanishes, so the generated initializer grows an argument and every Swift call site stops compiling. That is exactly what 3.2.0 did to NepaliDatePickerState and NepaliDateRangePickerState, and it is why the documented Swift path goes through the UIViewController factories and their options objects rather than the state classes: an options object absorbs a new field without changing anyone's call. If you expose Kotlin classes directly to Swift, your Kotlin notion of "additive" and your Swift consumers' notion of it are not the same thing, and semantic versioning has to follow the stricter one.
I also learned to treat that exported surface as something that can regress silently, so it is snapshot-tested: one task dumps the framework’s export list to a checked-in file, another diffs it on CI, and a third fails the build if a picker exists in Compose with no iOS factory behind it. Linking a framework takes minutes, so those run on the macOS leg only, not in the fast local loop.
Two more things worth planning for. First, offer a UI-free product too. Not every Swift consumer wants Compose, and the numbers make the case on their own: the picker XCFramework is an 83.9 MB download, while :core assembles its own Compose-free XCFramework at 5.9 MB zipped, published as a second product. They are deliberately mutually exclusive, since the UI framework statically embeds the core module and linking both would duplicate the Kotlin runtime. The Compose-free one also reaches further: it carries an Apple silicon macOS slice alongside the two iOS ones, which the picker framework cannot, because Compose Multiplatform publishes no embeddable AppKit host. A macOS app gets the calendar math and brings its own SwiftUI. Second, Apple architectures. Compose Multiplatform dropped Apple x86_64 in a recent release, so :ui cannot target the iOS simulator on Intel Macs even though :core still can. Document that consumers must exclude x86_64 for the simulator, or you will get confused issue reports from CI machines.
Destination 3: Flutter through pub.dev
This is the newest door and the one I put off longest, because there is no official bridge between Kotlin Multiplatform and Flutter. JetBrains documents the two as alternatives rather than neighbours, and the community projects that tried to marry them have gone quiet. That leaves two honest options: port the calendar to Dart, or bridge the binaries you are already publishing.
I bridged. A Dart port would have been a second implementation of the conversion table, and the PyPI section below is about what that costs even when you do it carefully. So nepali_date_picker_kmp is a thin Dart surface over the artifacts the two sections above already produce: on Android it resolves the ordinary Maven artifact, and on iOS it links the exact XCFramework the SPM release publishes. Nothing calendar-shaped is compiled twice. The engine that answers in Dart is the engine that answered in Kotlin and in Swift.
dependencies:
nepali_date_picker_kmp: ^3.3.0
Pigeon generates the channel contract. One schema file describes the messages and the types, and it emits the Dart, Kotlin and Swift ends together; CI regenerates them and fails if the committed files differ, so the bridge cannot drift from its schema. Pin the generator to an exact version, because codegen has to be byte stable across machines for that diff to mean anything.
The bridge was only affordable because of a property ** :core already had.** Its public API is entirely synchronous, has no coroutines or Flow anywhere in it, and does not mention a kotlinx-datetime type in a single public signature. It is ints, strings, booleans and the library's own flat value types. Every one of those absences would have been an argument at the channel boundary, and it is the same property that made the JavaScript facade possible a section later. If your core traffics in suspend functions or in types from a library the other runtime has never heard of, price the bridge before you promise it.
The honest tax is that everything is a Future. Platform channels are asynchronous by nature, so a table lookup that takes microseconds arrives in Dart as an awaited call. There is no way around it short of FFI, and I would rather say so in the README than let a consumer discover it while writing a build method.
Then the parts that only show up once the pickers themselves have to render.
- Compose has opinions about the Activity it is hosted in. A FlutterActivity is not a ComponentActivity, so a ComposeView placed inside one finds no lifecycle owner and no saved-state owner in its view tree and refuses to compose. Supply those and it still dies, because Compose's shared window recomposer reads the lifecycle off the window's content view, which in a Flutter app is the FlutterView and has none. The fix is a synthetic owner driven by the view's own attach and detach, plus a view-local recomposer installed through setParentCompositionContext so the window is never consulted at all. It installs itself only when the view tree provides nothing, so a normal Android app keeps its own owners.
- The height problem, for the third time. A platform view has no intrinsic content size either, exactly like a hosted UIViewController. Same contract, then: the native side reports its measured height, the Dart widget sizes itself from it. Three ecosystems, one lesson, which is how you know it is not an ecosystem's fault.
The packaging problem is the one I found most interesting, because it changed how releases work. A pub package is capped at roughly 100 MB and the iOS XCFramework unpacks to 265 MB, so vendoring it inside the package is simply not available. The plugin therefore keeps a local binary target for development and the release pipeline swaps in the released download URL and checksum, read from the SPM repository’s manifest at that tag. That is a good outcome, and it has a consequence: the SPM release must land before the pub release. My distributions now have an ordering, and the script that does the swap waits for the upstream manifest rather than racing it.
One more trap, and it rhymes with the npm one below. pub.dev’s trusted publishing cannot create a package. The OIDC exchange authenticates a release of a package that already exists and has GitHub Actions publishing enabled on its admin page, so on a first release it has nothing to authenticate against and falls back to an interactive prompt that no CI job can answer. The first version goes out by hand; every later one is automatic. Budget for that instead of debugging a workflow that is behaving correctly.
Two smaller things worth copying. Enums cross a generated bridge by index , so both ends pin the ordinals in tests; that contract is invisible in the source and breaks silently when someone inserts a case. And Kotlin/Native renames as it exports, so a Swift host sees short_, long_ and governmentpublic where Kotlin sees something tidier. Neither is hard. Both are only found by running the thing.
Finally, the bridge paid rent upstream. Android had no View-based wrapper around the composables, because nothing had needed one, so the work added androidMain view factories and dialog presenters mirroring the iOS ones, behind the same kind of coverage check that guards the iOS surface. Any View-based Android app gets that now, for free, and the new surface cannot quietly fall behind the pickers any more than the iOS one can. Work done for a bridge is rarely only for that bridge. The plugin covers Android and iOS; Flutter web and desktop consumers are pointed at the npm engine or the Maven artifact, which is the ecosystem map doing its job rather than an apology.
Destination 4: the web, and the honest npm story
This is the part I learned the most from, so I will tell it straight, including the wrong turn.
Kotlin/JS will happily produce an npm package. When you build the JS target, you get a publishable artifact, and it is tempting to think “great, the web is done.” It is not, and here is why.
That generated package is the Kotlin/JS runtime for your module. Its entry file only exports what you explicitly annotate with @JsExport. If you have not exported anything, a JavaScript developer who runs npm install and imports your package gets almost nothing usable: no convertAdToBs, no picker, just internal Kotlin symbols with mangled names. It bundles the whole Kotlin standard library (and, for a Compose app, Skiko and a WebAssembly canvas renderer) as its runtime. It is meant to be consumed by other Kotlin/JS code through the Kotlin toolchain, not hand written from JavaScript.
I confirmed this the blunt way: the published Kotlin/JS package’s entry module exported exactly one symbol, a timezone helper. That is correct for Kotlin interop and useless as a JavaScript date library.
So for the web I built two purpose-made packages instead, and treated JavaScript as a first-class consumer rather than a byproduct:
- @nepali-date-picker/core is the headless engine with a real, hand-designed JavaScript API: convertAdToBs, getTodayBs, formatBsDateByPattern, and so on, with TypeScript types and zero runtime dependencies. It is compiled from the same Kotlin :core, so the conversion tables match, but the public surface is designed for JavaScript, not leaked from Kotlin.
- @nepali-date-picker/web-component is a framework-agnostic custom element built on Lit, plus its variants (dialog, docked, range, text field, range field, wheel, and the browsable month calendar). Because custom elements are standard DOM, it drops into React, Vue, Angular, Svelte, or plain HTML with no wrapper.
<script type="module">import '@nepali-date-picker/web-component';</script>
<nepali-date-picker value="2081-05-24" language="ne"></nepali-date-picker>
That snippet, though, assumes a bundler. A library build and a drop-in build are not the same artifact, and I shipped only the first one at first. The library build externalizes its dependencies so a consumer’s bundler can deduplicate them, which means the published files import the bare specifiers lit and @nepali-date-picker/core. A browser loading that file from a CDN has no resolver for those names, so it fails. Correct for webpack and Vite, useless for a plain HTML page, and that second audience is large: a lot of the software that needs a Nepali calendar is a PHP or Django template with a tag and no build step at all.</p> <p>The fix is a second pass that inlines everything into one file, advertised through the exports map and the unpkg / jsdelivr fields. It is one request, currently 317 kB over the wire and 82 kB gzipped, and it registers all eight elements. Two details I would not have guessed:</p> <ul> <li><strong>Ship it as an ES module, not UMD.</strong> The instinct is to reach for a global build for maximum compatibility, but every browser that implements custom elements and shadow DOM also supports module scripts. A UMD build would only serve browsers that cannot render the component anyway.</li> <li><strong>Bundle the built output, not the sources.</strong> My first attempt bundled from src/, and the bundler silently dropped the side-effect imports that register the elements, because the sideEffects field in package.json is declared against dist/. The registrations survived only by accident, through unrelated named re-exports in the barrel file. Bundling dist/ fixes it and guarantees the CDN file is the same code the registry serves.</li> </ul> <p>The other thing worth writing down is what happened when I tried to type the elements for React. Custom elements are standard DOM, so the usual claim is that React 19 “just works” with them now. That is half true, and the half that is false costs real debugging time. <strong>React 19 fixed custom element properties, not events.</strong> I verified it rather than trusting the write-ups: onChange does fire, but React wraps the dispatched CustomEvent in its own synthetic event, so event.detail is undefined and the payload lives at event.nativeEvent.detail. Worse, any event not already in React's synthetic set never reaches an on-prefixed prop at all. Two of this library's events, invalid and cancel, simply never fire that way, no matter how they are dispatched.</p> <p>So the shipped TypeScript definitions encode the real behaviour: the change handler is typed to expose its payload only through nativeEvent, and no onInvalid or onCancel props are generated at all, because a prop that type-checks and silently does nothing is worse than no prop. Those definitions are generated from a custom-elements.json manifest rather than hand-written, so the element stays the single source of truth and a new property cannot drift out of the types.</p> <p>The lesson generalizes to any KMP library: <strong>exposing your code to an ecosystem is an API design task, not a build flag.</strong> The Kotlin/JS artifact is a transport mechanism. The developer experience is something you still have to author, whether that is @JsExport annotations with a clean facade or, as here, a small dedicated package that presents an idiomatic surface. (If you want the raw Kotlin/JS route instead, the work is the same shape: design and @JsExport a facade, do not ship the internals and hope.)</p> <p>One more npm-specific trap: <strong>your dev setup is not what consumers install.</strong> My showcase site loads the packages through local aliases, so it cannot catch a broken exports map, a missing files entry, or a dist that was never rebuilt. Those only surface after someone runs npm install. The cheap fix is a pre-publish check that packs both packages into tarballs, installs them into a throwaway project, imports them the way a consumer would, and bundles the element. It runs as a required gate in the publish workflow, so a package that cannot be installed cannot be released.</p> <p>If you publish from CI, prefer npm’s OIDC trusted publishing over a long-lived automation token. The workflow proves its identity to the registry per run and there is no secret sitting in the repository settings waiting to leak. It also buys you provenance: the versions I published by hand before setting it up carry no provenance badge, and the ones published from CI do, which is a visible difference on the package page.</p> <h3> <a name="destination-5-python-on-pypi" href="#destination-5-python-on-pypi" class="anchor"> </a> Destination 5: Python on PyPI </h3> <p>Some consumers are not on the JVM at all. Backends and data work in Nepal lean heavily on Python, so there is a sibling package, nepali_calendar_utils, published to PyPI.</p> <p>This one is a genuine port, not a compile target. Kotlin does not transpile to Python, so the utility logic is reimplemented. The one non-negotiable rule: <strong>the conversion tables must stay byte identical to the Kotlin **</strong> :core.** A Bikram Sambat date that converts to one Gregorian date in the Android app and a different one in the Python report is worse than having no Python package at all. I treat the Kotlin table as canonical and diff the Python table against it whenever calendar logic changes.</p> <p>A port also gets its own version track, and that is fine. The Python package sits a minor version behind the Kotlin coordinates right now, because the releases in between were picker and bridge work that a Python consumer has no equivalent of. What must never drift is the table, not the version number. Say that out loud in the README so nobody reads the gap as neglect.</p> <p>If you go this route, write the parity check as a test, not as a habit. Habits forget. Tests do not.</p> <h3> <a name="destination-6-the-web-demo-and-api-docs-on-github-pages" href="#destination-6-the-web-demo-and-api-docs-on-github-pages" class="anchor"> </a> Destination 6: the web demo and API docs on GitHub Pages </h3> <p>The last destination is not a package registry, it is discoverability. A library people cannot see running is a hard sell, and API docs behind a Gradle command do not get read.</p> <p>A single GitHub Actions workflow builds three things on every push to main and deploys them as one Pages site:</p> <ul> <li>the Compose wasmJs sample at the site root,</li> <li>the web-component showcase under /demo/,</li> <li>the Dokka API reference under /api/.</li> </ul> <p>Two things worth copying. First, GitHub Pages has a single live environment, so pull requests must not deploy: they would fight over the deploy lock and burn quota. PRs run tests through the CI workflow and nothing else; only main deploys. Second, trim the payload. The Compose wasmJs bundle is large because Skiko is large, so the workflow strips the JS source map before upload, which saves every visitor a download they never needed.</p> <h3> <a name="keeping-six-destinations-honest" href="#keeping-six-destinations-honest" class="anchor"> </a> Keeping six destinations honest </h3> <p>Publishing to six places is only sustainable if they cannot silently disagree. The things that keep this from becoming six subtly different libraries:</p> <ul> <li><strong>One source of truth for the calendar.</strong> Every target either compiles from :core, links a binary built from it, or is diffed against it. Nothing reimplements the conversion table casually.</li> <li><strong>Tests that assert parity</strong> , not documentation that requests it. That includes the boundaries between ecosystems: the iOS export snapshot, the two bridge-coverage checks, the regenerate-and-diff of the Flutter channel schema, the enum ordinals pinned on both ends of it, and the packed-tarball npm install are all just parity tests wearing different clothes.</li> <li><strong>A sample per consumption path.</strong> There is a Compose sample, a SwiftUI sample that links the XCFramework the way a real Swift app does, a Flutter showcase that mirrors the SwiftUI one screen for screen, and a web showcase. Each one is the first thing to break when a distribution regresses, which is exactly what you want, and CI builds the Swift and Flutter ones on every run.</li> <li><strong>Semantic versioning taken seriously</strong> , because a breaking change now ripples across six ecosystems with six different migration cultures. The 3.1.0 release was deliberately additive: every existing symbol kept working, and every new API was opt-in. 3.1.1 added two entire distributions without touching the Kotlin API, so Kotlin consumers upgraded by changing a version string. 3.2.0 put a whole second calendar into every picker with both new knobs defaulting to off, so an existing screen looks identical until it opts in, and the only break in the release was the Swift initializer one described above, which is the case where “additive in Kotlin” and “additive to consumers” come apart.</li> <li><strong>Centralized build configuration.</strong> Targets and toolchain versions live in convention plugins, so I change them once.</li> </ul> <h3> <a name="takeaways" href="#takeaways" class="anchor"> </a> Takeaways </h3> <p>If you are about to publish a KMP library beyond Maven Central, this is what I would tell past me:</p> <ol> <li>Make your core logic UI free and dependency light on day one. Every other destination depends on this being true, and retrofitting it is painful.</li> <li>Split artifacts along real dependency boundaries (core, UI, optional extras), not for tidiness. Offer a UI-free build to every ecosystem, not just the JVM one.</li> <li>Swift Package Manager wants a thin, separate repo with a binary framework. Plan for it, and generate the manifest from the release workflow so the checksum cannot drift.</li> <li>Every bridge is an API design task, not a build flag. The npm artifact Kotlin/JS hands you is a runtime, and the Objective-C export Kotlin/Native hands you is not a Swift API. Design the facade: options objects instead of lost default arguments, explicit size callbacks instead of intrinsic sizing you do not get.</li> <li>Bridging the binary you already ship beats porting, but only if your public API can survive the crossing. Synchronous, no runtime-specific types in signatures, plain values in and out. Audit that before you promise a second runtime anything.</li> <li>Check what “additive” means on the far side of each bridge before you promise it. A defaulted Kotlin parameter is a breaking change in Swift, and your version number has to answer to the strictest consumer, not the friendliest one.</li> <li>Snapshot the exported surface of every bridge and diff it on CI. Bridges rot quietly, because the compiler on your side stays happy.</li> <li>Verify what consumers actually install, not what your dev setup links. Pack it, install it in a throwaway project, import it.</li> <li>When one distribution pins another distribution’s artifact, your releases have an order. Encode the order in the pipeline and make it wait, rather than leaving it in a runbook nobody reads at 11pm.</li> <li>A registry’s automated publishing usually cannot create the package, only release it. Expect the first version of anything to go out by hand, and do not spend an evening debugging a workflow that is behaving correctly.</li> <li>The build a bundler wants is not the build a browser wants. If any of your audience has no build step, and on the web a lot of it does not, ship a second self-contained artifact and let a CDN serve it.</li> <li>Test the platform claims you are about to encode, rather than trusting the write-ups. “React 19 supports custom elements” is true about properties and false about events, and I would have shipped types describing behaviour that does not exist if I had not checked.</li> <li>A non-JVM port lives or dies on data parity. Enforce it with a test, and let its version number drift if it needs to.</li> <li>Ship a running demo and hosted API docs. Discoverability is a feature.</li> </ol> <p>One library, six front doors, one calendar that agrees with itself everywhere. That was the whole point.</p> <p><strong>Links</strong></p> <ul> <li>Source: <a href="https://github.com/shivathapaa/Nepali-Date-Picker">https://github.com/shivathapaa/Nepali-Date-Picker</a></li> <li>Live demo: <a href="https://shivathapaa.github.io/Nepali-Date-Picker/demo/">https://shivathapaa.github.io/Nepali-Date-Picker/demo/</a></li> <li>API reference: <a href="https://shivathapaa.github.io/Nepali-Date-Picker/api/">https://shivathapaa.github.io/Nepali-Date-Picker/api/</a></li> <li>Swift guide: <a href="https://github.com/shivathapaa/Nepali-Date-Picker/blob/main/README-spm.md">https://github.com/shivathapaa/Nepali-Date-Picker/blob/main/README-spm.md</a></li> <li>Flutter guide: <a href="https://github.com/shivathapaa/Nepali-Date-Picker/blob/main/README-flutter.md">https://github.com/shivathapaa/Nepali-Date-Picker/blob/main/README-flutter.md</a></li> <li>Web guide: <a href="https://github.com/shivathapaa/Nepali-Date-Picker/blob/main/README-js.md">https://github.com/shivathapaa/Nepali-Date-Picker/blob/main/README-js.md</a></li> <li>Maven Central: <a href="https://central.sonatype.com/namespace/io.github.shivathapaa">https://central.sonatype.com/namespace/io.github.shivathapaa</a></li> <li>Swift package: <a href="https://github.com/shivathapaa/Nepali-Date-Picker-SPM">https://github.com/shivathapaa/Nepali-Date-Picker-SPM</a></li> <li>Flutter package: <a href="https://pub.dev/packages/nepali_date_picker_kmp">https://pub.dev/packages/nepali_date_picker_kmp</a></li> <li>npm: <a href="https://www.npmjs.com/package/@nepali-date-picker/web-component">https://www.npmjs.com/package/@nepali-date-picker/web-component</a></li> <li>Python sibling: <a href="https://pypi.org/project/nepali_calendar_utils/">https://pypi.org/project/nepali_calendar_utils/</a></li> </ul> <p>Drop a ❤️ if this was useful — it helps more developers find it. And follow for more upcoming contents (single codebase, six apps in playstore).</p>

Top comments (0)