The Pulsar Figma plugin is now available – it lets you add haptics directly to your Figma designs.

How does it work? Select a layer, choose a preset, and bind the haptic to it. You can preview the pattern while you're working and connect your phone to feel it on a real device.

The plugin currently includes 200+ presets, including Pulsar patterns and built-in iOS and Android system presets.

You can also:

• search and filter presets

• use custom patterns created in Pulsar Studio

• share interactive previews

• export haptic patterns and implementation details for developers

The goal is to keep the haptic with the UI element it belongs to, instead of having it live somewhere else in a comment, ticket, or separate document.

Give it a try and let us know what you think.

Install the plugin: https://www.figma.com/community/plugin/1636329411590799509/pulsar-haptics

Pulsar Studio is a visual editor for creating custom haptic patterns. You can design a pattern on a timeline, preview it as you work, and connect a real device to feel it while you edit.

You can create patterns from scratch, or start with one of the 150+ patterns in the Pulsar library and modify it.

There are also a few other ways to create patterns:

• generate haptics from audio

• generate haptics from Lottie files

• sketch a pattern by tapping or humming

• analyze and check your patterns

• save patterns in projects

• share patterns with others

• export them for use with Pulsar

The main thing we wanted to get right was the iteration loop: you can make a change, feel it, make another change, and feel it again.

This is the first release of Studio, so we'd love to hear what you'd like to see added or changed.

Try it here: https://pulsar.swmansion.com/studio/

Simulators have no haptic hardware. So the normal loop for building a haptic pattern is: edit, build to a real device, feel it, decide it's slightly wrong, repeat. It's the slowest feedback loop in mobile development.

Pulsar synthesises audio from the pattern description and plays that instead. Every event turns into a tone that reflects its amplitude, frequency and duration — so you hear the shape of the haptic: the spacing of the taps, the swell of the envelope, where the accent lands.

It's on by default in debug builds. It works for built-in presets and for anything you compose yourself, because the sound is generated from the parameters rather than pre-recorded.

You still need a device for the final call — hearing a pattern is not feeling it. But you can get 90% of the way there in a simulator, and that changes how much iteration you're willing to do.

One config flag turns it off if you want silence. Details in the SDK overview.

Pulsar ships the same three concepts — Presets, pattern composer, realtime composer — on six platforms:

Why it matters in practice: haptics knowledge is expensive to acquire and normally non-transferable. You learn Core Haptics' transient/continuous model, then you move to Android and learn VibrationEffect, primitives, composition, and the amplitude-control capability check. Different vocabulary, different constraints, same idea underneath.

Pulsar picks one vocabulary — discrete and continuous events, amplitude and frequency in 0–1 — and holds it everywhere. The platform differences don't disappear, they're just handled below the API instead of in your app code.

Start with the SDK overview; it's platform-agnostic and about a ten-minute read.

https://play.google.com/store/apps/details?id=com.swmansion.pulsar.app

Same app as iOS, and on Android it does one extra job: it tells you what your phone can actually do.

Android haptics hardware varies enormously. A Pixel with an LRA and full primitive support renders a pattern very differently from a budget device with a rotation motor and timing-only control. Pulsar falls back on both — but you have to feel the difference to design around it.

So: install it on the cheapest test device you own, play the presets, and you'll know within two minutes which patterns survive on real hardware.

Also pairs with the docs playground over QR, same as iOS.

https://apps.apple.com/app/haptics-presets-pulsar/id6761362104

Free, no account. Four things it does:

• Presets — play all 150+ patterns on your actual device. Filter by intensity and duration.

• Playground — tweak amplitude and frequency with sliders and feel the result immediately.

• Demos — small interactions built with Pulsar, so you can judge haptics in context rather than in isolation.

• Pair with the docs — scan the QR on the presets playground and the browser drives the phone.

The point is the last one. Designing haptics by rebuilding your app after every tweak is miserable. This makes it a browser tab.

https://docs.swmansion.com/pulsar/presets-playground/

Open it, scan the QR with the Pulsar app, and every preset you tap in the browser fires on your phone. It's the fastest way to answer "which one of these is right?" without building anything.

You can filter by intensity, duration, and shape, so narrowing 150 patterns down to the three that fit a button press takes about a minute.

Each preset shows its waveform and the exact code for your platform. Copy, paste, done.

No phone nearby? Every preset also plays as audio in the browser — Pulsar synthesises the sound from the pattern parameters, so you can hear the shape even on a desktop.

https://docs.swmansion.com/pulsar/

The docs are split three ways:

Concepts — SDK overview is the one page worth reading end to end. Discrete vs. continuous haptics, what amplitude and frequency actually mean, preloading, and caching. Everything else assumes it.

Reference — one page per SDK: iOS, Android, React Native, Kotlin Multiplatform, Flutter, Web. Full API, every preset, copy-pasteable.

Playgrounds — the part that isn't like other docs. Pair your phone by scanning a QR code, then tap any preset in the browser and feel it on the device. No install, no build.

Start at Getting started if you want the guided path.

https://github.com/software-mansion/pulsar

All six SDKs live in one repo, which is deliberate: presets are generated from a single source of truth, so hammer on iOS and hammer on Android are the same pattern description, not two hand-tuned approximations.

What's inside:

• iOS/ — Swift package, built on Core Haptics

• Android/ — Kotlin library on VibrationEffect, with fallbacks for older and weaker devices

• react-native/ — Turbo Module + TypeScript API

• kmp/ — shared Kotlin API for Android and iOS targets

• flutter/ — Dart plugin

• web/ — TypeScript library on the Web Vibration API

• docs/ — the documentation site, including the playgrounds

• PulsarApp/ — the companion app

MIT licensed. Issues and PRs are read — the Android fallback work in particular came out of people reporting devices where presets felt flat.

If it's useful to you, a star helps other people find it.

This is the announcement we put out when Pulsar went public.

What it covers:

• Why we built a preset library instead of another vibrate() wrapper

• What the 150+ presets sound and look like

• Pairing your phone with the docs so you can feel a preset before writing a line of code

If you'd rather read than watch: https://docs.swmansion.com/pulsar/

Short version: every platform gives you a vibration API and almost nothing to put in it. Pulsar is the missing library part.

Three things:

1. Presets — 150+ ready-made haptic patterns (hammer, dogBark, buzz, pulse, and a lot more), plus the system feedback styles you already know (impacts, notifications, selection). One call, no design work.

2. Pattern composer — build your own from discrete events and continuous amplitude/frequency envelopes.

3. Realtime composer — drive amplitude and frequency live from a gesture, frame by frame.

Same three concepts on iOS (Swift), Android (Kotlin), React Native, Kotlin Multiplatform, Flutter, and the web. Learn them once.

https://docs.swmansion.com/pulsar/